leetcode加油站, 分发糖果，根据身高重建队列，用最少数量的箭引爆气球(贪心)

暴力解法
for循环适合模拟从头到尾的遍历，而while循环适合模拟环形遍历，要善于使用while

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for (int i = 0; i < gas.size(); i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {   // 当前累加rest[i]和 curSum一旦小于0
                start = i + 1;  // 起始位置更新为i+1
                curSum = 0;     // curSum从0开始
            }
        }
        if (totalSum < 0) return -1; // 说明怎么走都不可能跑一圈了
        return start;
    }
};

贪心

能最后回到起始位置的条件是总油量减去总消耗量要大于等于0，即每个位置的剩余油量和得大于等于0。
每个位置的剩余油量为rest[i] = gas[i] - cost[I];

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int totalSum = 0;
        int curSum = 0;
        int start = 0;
        for(int i = 0; i < gas.size(); i++){
            totalSum += (gas[i] - cost[i]);
            curSum += (gas[i] - cost[i]);

            if(curSum < 0){
                start = i + 1;
                curSum = 0;
            }
        }

        if(totalSum < 0) return -1;

        return start;
    }
};

贪心

在使用局部最优时，不能同时考虑左边和右边，这样会顾此失彼。
正确方法是：先从左往右遍历，比较右孩子是否大于左孩子，若大于则为左孩子糖果数+1。 再从右往左遍历，比较左孩子是否大于右孩子，若大于则取右孩子+1和自己本身的最大值，这样就可以保证当前位置即大于左孩子的糖果数又大于右孩子的糖果数。

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> vec(ratings.size(), 1);

        //先从左往右遍历
        for(int i = 1; i < ratings.size(); i++){
            if(ratings[i] > ratings[i-1]) vec[i] = vec[i-1] + 1;
        }

        //再从右往左遍历
        for(int i = ratings.size() - 2; i >= 0; i--){
            if(ratings[i] > ratings[i+1]) vec[i] = max(vec[i+1] + 1, vec[i]);
        }
        int sum = 0;
        
        for(int i = 0; i < vec.size(); i++)
            sum += vec[i];

        return sum;
    }
};

贪心

和分糖果一样存在两个维度，故因分开处理两个维度，以免顾此失彼。 从题目可以看出，应该先按身高从大到小排序，若身高相同，则按k值从小到大排序（这样子的话在插入的时候，身高相同但k较大的总在后面一个位置）。
从身高高的人开始插入，插入位置为k（k为每个身高应该插入的位置下标）。

class Solution {
public:
    static bool cmp(vector<int> &a, vector<int> &b){
        if(a[0] == b[0]) return a[1] < b[1];

        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);

        vector<vector<int>> que;
        for(int i = 0; i < people.size(); i++){
            int pos = people[i][1];
            que.insert(que.begin() + pos, people[i]);

        }

        return que;
    }
};

vector的底层实现是普通数组，vector的大小有两个维度，一个是size（就是我们平时遍历时用的），一个是capacity，当插入的个数大于capacity的时候，就会自动关扩容至原来的2倍，然后再把原数据拷过去。故insert的操作时复为O(n^2)。

故可以采用list，插入为O(1)

class Solution {
public:
    static bool cmp(const vector<int> &a, const vector<int> &b){
        if(a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }

    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(), people.end(), cmp);

        list<vector<int> > res;

        for(int i = 0; i < people.size(); i++){
            int index = people[i][1];
            list<vector<int>>::iterator it = res.begin();
            while(index--){
                it++;
            }

            res.insert(it, people[i]);
        }

        return vector<vector<int>>(res.begin(), res.end());
    }
};

首先按起点进行排序，若后一个球的起点小于等于前一个气球的终点，则二者重合，此时更新重合气球的最小右边界，即points[i][1] = min(points[i][1], points[i-1][1])，则最小右边界前的气球至少需要一个箭。(核心是不断更新最小右边界)

class Solution {
public:
    static bool cmp(const vector<int> &a, const vector<int> &b){

        return a[0] < b[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.size() == 1) return 1;
        sort(points.begin(), points.end(), cmp);
        int res = 1;  //第一组重叠气球，一定是需要一个箭

        for(int i = 1; i < points.size(); i++){
            if(points[i-1][1] < points[i][0]) res++;
            else{
                points[i][1] = min(points[i][1], points[i-1][1]);
            }
        }

        return res;
        
        
        
    }
};

思路：首先按右区间进行排序，这样就可以优先保留右边界小的，这样留给下一个区间的位置就大了。局部最优从而全局最优。

class Solution {
public:
    static bool cmp(const vector<int> &a, const vector<int> &b){
        
        return a[1] < b[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        //[1, 2] [1, 3] [2, 3] [3,4]
        //[1, 11] [1, 100] 
        sort(intervals.begin(), intervals.end(),cmp);
        
        int res = 0;

        for(int i = 1; i < intervals.size(); i++){
            if(intervals[i][0] < intervals[i-1][1]){
                res++;
                intervals[i][1] = intervals[i-1][1];//更新最小右边界
            }
        }

        return res;

    }
};

思路：找到每个字母出现的最后位置，然后从头开始遍历，不断更新最右边界，若当前的i等于最右边界，则分隔开。

class Solution {
public:
    vector<int> partitionLabels(string s) {
        //ababcbaca fegde  hijhklij
        unordered_map<char, int> mp;
        vector<int> res;

        //找到每个字母出现的最后位置
        for(int i = 0; i < s.size(); i++){
            if(mp.find(s[i]) == mp.end()){
                int j = s.size()-1;
                while(i <= j){
                    if(s[j] == s[i]){
                        mp[s[i]] = j;
                        break;
                    }
                    else j--;
                }
            }
        }

        int dis = 0; //最远右边界
        int del = 0;  //分隔点
        for(int i = 0; i < s.size(); i++){
            dis = max(dis, mp[s[i]]);
            if(i == dis){
                res.push_back(i - del + 1);
                del = i + 1;
                dis = 0;
            }
        }

        return res;
    }
};