力扣笔记：452\435\763\56\738

总结：
一定要先画图！一定要先画图！一定要先画图！一定要先画图！

452. 用最少数量的箭引爆气球
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

 
示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球
示例 2：

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2
示例 4：

输入：points = [[1,2]]
输出：1
示例 5：

输入：points = [[2,3],[2,3]]
输出：1
 

提示：

1 <= points.length <= 104
points[i].length == 2
-231 <= xstart < xend <= 231 - 1

这一题的解答可以参考官方解答以及carl大佬的笔记，附上链接：
https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/solution/yong-zui-shao-shu-liang-de-jian-yin-bao-qi-qiu-1-2/

https://programmercarl.com/0452.%E7%94%A8%E6%9C%80%E5%B0%91%E6%95%B0%E9%87%8F%E7%9A%84%E7%AE%AD%E5%BC%95%E7%88%86%E6%B0%94%E7%90%83.html#%E6%80%9D%E8%B7%AF

大致意思就是尽可能的让每一支箭击穿更多的气球（废话）
那么为了达成这个目的，我们就要找到重叠状态更多的气球，找到重叠状态最多的气球将其击破，再处理剩下的重叠状态次优的气球，以此类推。

思想转化为代码就是两种方法：
1、将气球按照左值排序，当左值不超过之前气球右值时，那么气球重叠（因为经过排序后默认左值小于前面出现的气球），这里注意的是右值，我们必须要持续记录右值最小的状态。
为什么？（这个问题也和第二种方法以及困惑我的地方有关），考虑{2，8}{3，4}{6，10}，画图后发现这是需要两支箭才能解决的情况。如果我们仅仅考虑左值，那么会错判只需要一支箭。因此我们可以发现当气球的左值大于前面出现的气球的右值最小值时，即使左值在之前气球的重叠范围内，也没办法一支箭解决所有气球。所以当左值大于右值最小值，需要增加一支箭

2、（详细看官方解答）

第一种解答：
这里困扰我的，也是非常重要的地方在于：
之前一直提交都出现超时错误，后来发现原因是cmp函数
其中的形参必须使用引用赋值的方法，在一开始的时候我是采用直接赋值的方法即没有加上引用符号。超时原因应该是因为原数组数量多而且是二维数组，在快速排序持续地调用cmp时，时间开销大

class Solution {
public:
    static bool cmp(vector<int> &A,vector<int> &B){
        return A[0] < B[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(),points.end(),cmp);
        int left = points[0][0];
        int right = points[0][1];
        int ans = 1;
        for(int i = 1;i < points.size();++i){
            if(points[i][0] > right){
                ans++;
                left = points[i][0];
                right = points[i][1];
            }
            else{
                right = min(right,points[i][1]);
            }
        }
        return ans;
    }
};

第二种解答：

class Solution {
public:
    static bool cmp(vector<int> &A,vector<int> &B){
        return A[1] < B[1];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(),points.end(),cmp);
        int right = points[0][1];
        int ans = 1;
        for(int i = 1;i < points.size();++i){
            if(points[i][0] > right){
                ans++;
                right = points[i][1];
            }
        }
        return ans;
    }
};

435. 无重叠区间
给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。
示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
示例 3:

输入: [ [1,2], [2,3] ]

输出: 0

解释: 你不需要移除任何区间，因为它们已经是无重叠的了

这一题与上题类似，这种题最难的地方在于根本不知道要用贪心算法，又或者是不知道贪心在哪里(这一点对我来说暂时无解，可能要多做题才有题感吧)

先画图，画图后发现想要移除最少区间，肯定是每次去掉长的区间，保留短的区间。在这一步的基础上接着思考，就会想到每次保留右边界更小的区间，这样留给接下来的区间空间会更大。因为没想到反例，所以先用这个想法贪心算法试着做

方法一：

class Solution {
public:
    static bool cmp(vector<int> &A,vector<int> &B){
        return A[0] < B[0];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),cmp);
        int right = intervals[0][1];
        int ans = 0;
        for(int i = 1;i < intervals.size();++i){
            if(intervals[i][0] < right){
                ans++;
                if(right > intervals[i][1]){
                    right = intervals[i][1];
                }
            }
            else{
                right = intervals[i][1];
            }
        }
        return ans;
    }
};

方法二：
https://programmercarl.com/0435.%E6%97%A0%E9%87%8D%E5%8F%A0%E5%8C%BA%E9%97%B4.html#_435-%E6%97%A0%E9%87%8D%E5%8F%A0%E5%8C%BA%E9%97%B4
方法类似，只是他的做法时间消耗更小（大概是因为循环体中这种方法的判断语句更少，判断语句的时间消耗确实大）

方法是既然要保留右边界更小的区间，那么干脆就按照右边界进行排序。记录非重叠的区间，返回总区间数减去非重叠区间数。

class Solution {
public:
    static bool cmp(vector<int> &A,vector<int> &B){
        return A[1] < B[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end(),cmp);
        int right = intervals[0][1];
        int ans = 1;
        for(int i = 1;i < intervals.size();++i){
            if(right <= intervals[i][0]){
                right = intervals[i][1];
                ++ans;
            }
        }
        return intervals.size() - ans;
    }
};

763. 划分字母区间
字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

 

示例：

输入：S = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca", "defegde", "hijhklij"。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。
 

提示：

S的长度在[1, 500]之间。
S只包含小写字母 'a' 到 'z' 。

解答思路：
https://programmercarl.com/0763.%E5%88%92%E5%88%86%E5%AD%97%E6%AF%8D%E5%8C%BA%E9%97%B4.html#%E6%80%9D%E8%B7%AF

class Solution {
public:
    vector<int> partitionLabels(string S) {
        int hash[27] = {0}; // i为字符，hash[i]为字符出现的最后位置
        for (int i = 0; i < S.size(); i++) { // 统计每一个字符最后出现的位置
            hash[S[i] - 'a'] = i;
        }
        vector<int> result;
        int left = 0;
        int right = 0;
        for (int i = 0; i < S.size(); i++) {
            right = max(right, hash[S[i] - 'a']); // 找到字符出现的最远边界
            if (i == right) {
                result.push_back(right - left + 1);
                left = i + 1;
            }
        }
        return result;
    }
};

优先使用上一种，因为下面一种是n^2的写法，根本没必要，时间消耗更大

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int L = s.size();
        int left = 0;
        int right = 0;
        vector<int> res;
        for(int i = 0;i < L;++i){
            char temp = s[i];
            for(int j = i + 1;j < L;++j){
                if(temp == s[j]){
                    right = max(right,j);
                }
            }
            if(right == L - 1){
                res.emplace_back(right - left + 1);
                break;
            }
            if(right == i){
                res.emplace_back(right - left + 1);
                left = right + 1;
                right = left;
            }
        }
        return res;
    }
};

56. 合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

 

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
 

提示：

1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104

和452\435类似，这题很简单，就是将重叠的区间合并起来，也没什么贪心的思想在里面，剩下的就只有实现了

快速排序左边界，将左边界位于上一区间之中的两个区间进行合并（在实现过程中其实就是维护一个左边界和右边界，左边界始终保持在重叠区间的最左端，右边界保持在重叠区间的最右端，当碰到不重叠的区间时，将左边界和右边界维护的区间输入到结果数组中，将左边界和右边界初始为下一区间的左右边界）。需要注意的是在循环体中最后一个区间没有办法加入到结果数组中，需要另外处理

class Solution {
public:
    static bool cmp(vector<int> &A,vector<int> &B){
        return A[0] < B[0];
    }
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        int L = intervals.size();
        sort(intervals.begin(),intervals.end(),cmp);
        vector<vector<int> > res; 
        int left = intervals[0][0];
        int right = intervals[0][1];
        for(int i = 1;i < L;++i){
            if(intervals[i][0] <= right){
                right = max(right,intervals[i][1]);
            }
            else{
                vector<int> temp = {left,right};
                res.emplace_back(temp);
                left = intervals[i][0];
                right = intervals[i][1];
            }
        }
        vector<int> temp = {left,right};
        res.emplace_back(temp);
        return res;
    }
};

738. 单调递增的数字
给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）

示例 1:

输入: N = 10
输出: 9
示例 2:

输入: N = 1234
输出: 1234
示例 3:

输入: N = 332
输出: 299
说明: N 是在 [0, 10^9] 范围内的一个整数。

这题的难点是主要是实现的问题（也就是反向遍历）

这道题的解决方法很容易想到就是找到n中位于前面的递增序列，将第一个不符合递增数字及其直到最后的数字置为9，将最后一个符合递增序列的数字减一

问题在于实现，由于需要确定从开始位置到之后某点区间内皆为递增，就很容易本能地从数字的开头开始正向遍历，但是这样就有一个问题，根据上面的解决思想，我们需要将最后一个符合递增序列的数字减一，但是减一后的数字是否仍然保持递增特性我们没法确定，导致我在一开始尝试使用多个标识符记录当前、前一个和后一个位置都没办法AC。

反向遍历好处在于对于最后一个符合递增序列的数字减一的处理，由于我们从后往前遍历，这样我们地每一步操作都可以将上一步的操作考虑在内，也不会出现减一后破坏了递增特性的情况。反向遍历找到需要减一数字的位置，之后再通过正向遍历将之后的数字置为9。

当然，这一题将整型数字转化为字符串也是个关键操作（只是比较容易想到，反向遍历与人为思考刚好相反没能想到）

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        string s = to_string(n);
        if(s.size() == 0){
            return 0;
        } 
        int flag = s.size();
        for(int i = s.size() - 1;i > 0;--i){
            if(s[i] < s[i - 1]){
                flag = i;
                s[i - 1]--;
            }
        }
        for(int i = flag;i < s.size();++i){
            s[i] = '9';
        }
        return stoi(s);
    }
};