贪心:leetcode 870. Advantage Shuffle、134. Gas Station、452. Minimum Number of Arrows to Burst Balloons、316. Remove Duplicate Letters

870. Advantage Shuffle

思路：A数组的最大值大于B的最大值，就拿这个A跟B比较；如果不大于，就拿最小值跟B比较

A可以改变顺序，但B的顺序不能改变，只能通过容器来获得由大到小的顺序，并且必须存储相应的index，因为最终需要将选择的A的数值存入与这个B相对应的index下

class Solution {
public:
    vector<int> advantageCount(vector<int>& A, vector<int>& B) {
        vector<int> result(A.size());
        sort(A.begin(),A.end());
        priority_queue<pair<int,int>> q;
        for(int i = 0;i < B.size();i++)
            q.push({B[i],i});
        int left = 0,right = A.size() - 1;
        while(left <= right){
            int num = q.top().first;
            int index = q.top().second;
            q.pop();
            if(A[right] > num){
                result[index] = A[right];
                right--;
            }
            else{
                result[index] = A[left];
                left++;
            }
        }
        return result;
    }
};

 134. Gas Station

https://www.cnblogs.com/grandyang/p/4266812.html

当到达某一站点时，若这个值小于0了，则说明从起点到这个点中间的任何一个点都不能作为起点，则把起点设为下一个点，继续遍历

注意：这里int初始化的时候都要写=0，自己电脑上不初始化，初始化的结果为-1，oj上则是随机在初始化。至于这个的原因，我可能还要继续学习一下。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int sum = 0,cur_sum = 0,index = 0;
        for(int i = 0;i < gas.size();i++){
            sum += gas[i] - cost[i];
            cur_sum += gas[i] - cost[i];
            if(cur_sum < 0){
                cur_sum = 0;
                index = i+1;
            }
        }
        return sum < 0 ? -1 : index;
    }
};

452. Minimum Number of Arrows to Burst Balloons

在x轴上，给你一串气球在轴上开始和结束的位置索引，从轴上某一点发射一根箭，能刺破气球。问最少需要多少根箭刺破气球。

或者说：这些气球沿X轴方向摆放，每个气球大小可能不同，一个气球占据的区间可以表示为[Xstart,Xend]，气球可以重叠摆放。一支坐标为x的箭，可以扎破所有满足 Xstart <= x <= Xend 的气球，求出最少射几支箭可以将所有气球扎破。

这个题和区间相交有点像，按顺序将气球排列，如果有交集，同一根箭就能同时刺破两个气球。所以按照位置索引的开始位置进行排序，然后贪心地以结束位置为箭发射的位置，只要相交，就能刺破，但必须更新这个位置，有可能下一个气球的second比前一个小。如果不相交，就更新index，并增加箭的个数。

sort对pair的排序默认是以first的升序排列的，所以sort不用改tmp函数

注意：以第一个气球为出发，所以res为1；同时如果发射箭的位置等于了坐标，也应该能刺破，所以index >= points[i][0]

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.empty() || points[0].empty())
            return 0;
        int res = 1;
        sort(points.begin(),points.end());
        int index = points[0][1];
        for(int i = 1;i < points.size();i++){
            if(index >= points[i][0])
                index = min(index,points[i][1]);
            else{
                index = points[i][1];
                res++;
            }
        }
        return res;
    }
};

316. Remove Duplicate Letters

https://www.cnblogs.com/grandyang/p/5085379.html

删除重复的，让最后的字符串没有重复的单词，并且要保证大小写的顺序和原本字符串中的相对位置。

class Solution {
public:
    string removeDuplicateLetters(string s) {
        vector<int> container(26,0);
        vector<bool> visited(26,false);
        string res = "0";
        for(int i = 0;i < s.size();i++)
            container[s[i] - 'a']++;
        for(int i = 0;i < s.size();i++){
            container[s[i] - 'a']--;
            if(visited[s[i] - 'a'])
                continue;
            while(s[i] < res.back() && container[res.back() - 'a'] > 0){
                visited[res.back() - 'a'] = false;
                res.pop_back();
            }
            res += s[i];
            visited[s[i] - 'a'] = true;
        }
        return res.substr(1);
    }
};