LeetCode相关典型题解合集——贪心法

所有的题型目录在下面的链接
LeetCode相关典型题解合集（两百多道题）

---

贪心和动态规划本质的区别是什么？

两者相似的地方在于技巧性地设计子问题。
动态规划希望复用子问题的解，最好被反复依赖。其本质还是穷举，所以当前并不知道哪个子问题的解会构成最终最优解。但知道这个子问题可能会被反复计算，所以把结果缓存起来。整个过程是树状的搜索过程。
贪心希望每次都能排除一堆子问题。它不需要复用子问题的解，当前最优解从子问题最优解即可得出。整个过程是线性的推导过程。
贪心算法具有后无效性

---

455. Assign Cookies (Easy)

对孩子的胃口g和饼干的大小s进行排序，然后比较就行

int findContentChildren(vector<int>& g, vector<int>& s) {
        //先排序
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int num_child=g.size();
        int num_cookie=s.size();
        int count=0;
        for(int i=0,j=0;i<num_child&&j<num_cookie;i++,j++){
            //胃口不匹配饼干，饼干索引往后
            //饼干数不能越界
            while(g[i]>s[j]&&j<num_cookie){
                j++;
            }
            //饼干数只能有给定的那么多
            if(j<num_cookie){
                count++;
            }
        }
    }

121. Best Time to Buy and Sell Stock (Easy)

---

股票问题一共有六道：买卖股票的最佳时机 1，2，3，4、含冷冻期、含手续费。

股票问题的方法就是 动态规划，因为它包含了重叠子问题，即买卖股票的最佳时机是由之前买或不买的状态决定的，而之前买或不买又由更早的状态决定的…

---

思路遍历一遍数组，计算每次 到当天为止 的最小股票价格和最大利润。

int maxProfit(vector<int>& prices) {
        int minPrice=1e9;
        int maxProfit=0;
        for(auto price:prices){
            minPrice=price>minPrice?minPrice:price;
            maxProfit=(price-minPrice)>maxProfit?(price-minPrice):maxProfit;
        }
        return maxProfit;
    }

122. Best Time to Buy and Sell Stock II (Easy)

思路：重点记住上涨交易日股票的价格等价于每天都买卖，非常重要！
因此遍历整个股票交易日价格列表 price，所有上涨交易日都买卖（赚到所有利润），所有下降交易日都不买卖（永不亏钱）。

int maxProfit(vector<int>& prices) {
        int minPrice=1e9;
        int maxProfit=0;
        for(int i=0;i<prices.size()-1;i++){
            if(prices[i]<prices[i+1]){
                maxProfit+=prices[i+1]-prices[i];
            }
        }
        return maxProfit;
    }

665. Non-decreasing Array (Easy)

思路：这道题必须瞻前顾后才能做
首先定位到出现逆序位的第一位，比如3,4,2,3，其逆序位第一位是4
设此位为i
那么考虑，如果要有序，必须考虑i或者i+1做出改变
那么到底是改变i还是改变i+1，需要瞻前顾后的看
对于3423这个数组来说，4无法改变，因为4变成3，后面又开始出现逆序了。如果4变成了2，那么也还有逆序，对于3425这个数组，同理
这两个数组都有一个共同特征就是i-1>i+1，这种情况下不能改变i，必须改变i+1
对于1254这个数组来说，5这里出现了逆序，设为i。那么因为i-1<i+1，因此改变i即可
以上就是本题的思路

bool checkPossibility(vector<int>& nums) {
        int count=0;
        for(int i=0;i<nums.size()-1;i++){
            if(nums[i]>nums[i+1]){
                count++;
                //当定位为第一位或者左边小于等于右边时候
                if(i==0||nums[i-1]<=nums[i+1]){
                    nums[i]=nums[i+1];
                }
                //当左边大于右边的时候
                else if(nums[i-1]>nums[i+1]){
                    nums[i+1]=nums[i];
                } 
            }
        }
        return count<=1;
    }

605. Can Place Flowers (Easy)

思路：就是贪心法，一个一个遍历。考虑一下前后位置和第一个和最后一个位置就行

bool canPlaceFlowers(vector<int>& flowerbed, int n) {
        for(int i=0;i<flowerbed.size();i++){
            if(flowerbed[i]==0&& (i==0||flowerbed[i-1]==0) &&((i==flowerbed.size()-1)||flowerbed[i+1]==0)){
                n--;
                if(n<=0){
                    return true;
                }
                flowerbed[i]=1;
            }
        }
        //不返回false是因为如果n等于0，又没有种的地儿，返回true
        return n<=0;
    }

53. Maximum Subarray (Easy)

思路：首先遍历数组，设一个表示数组元素依次相加的合，和一个表示最大值的MaxSum
如果数组元素合小于0，那么sum就等于下一个元素，把之前的合去掉
如果每次循环sum的合大于0，则比较此时的sum和MaxSum的大小，取最大值即可

int maxSubArray(vector<int>& nums) {
        int sum=0;
        //maxSum之所以不初始化为0，要考虑[-1]这种情况
        int maxSum=nums[0];
        for(auto n:nums){
            sum=0>sum?0:sum;
            sum=sum+n;
            maxSum=maxSum<sum?sum:maxSum;
        }
        return maxSum;
    }

435. Non-overlapping Intervals (Medium)

思路：贪心法。首先对区间进行遍历，具体参考sort函数的最后一个参数的写法
遍历区间：

1. 后面区间的头小于当前区间的尾，
   比如当前区间是[3,6]，后面区间是[4,5]或者是[5,9]
   说明这两个区间有重复，必须要移除一个，那么要移除哪个呢，为了防止在下一个区间和现有区间有重叠，我们应该让现有区间越短越好，所以应该移除尾部比较大的，保留尾部比较小的。
2. 如果后面区间的头不小于当前区间的尾，说明他们没有重合，不需要移除

 //定义排序函数
    static bool myFunction(vector<int> &a,vector<int> &b){
        return a[1]<b[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size()==0){
            return 0;
        }
        //对数组进行由大到小排序
         sort(intervals.begin(),intervals.end(),myFunction);
        int end=intervals[0][1];
        //count记录的是非交叉区间的个数，第一个元素一定是非交叉区间
        int count=1;
        for(int i=1;i<intervals.size();i++){
            //满足前一个数组的最后一个小于等于后一个数组的第一个，则是没有重叠的区间
            //找不重叠的区间容易
            if(end<=intervals[i][0]){
                end=intervals[i][1];
                count++;
            }
        }
        return intervals.size()-count;
    }

452. Minimum Number of Arrows to Burst Balloons (Medium)

思路：和上一题类似，这种都需要对区间进行操作，可以细品
这道题还是得先排序，按照区间尾部大小进行排序。原因是：根据贪心法，我们希望箭尽可能的少，也就是区间尽可能多的重合，这就需要以尾部大小来排序，这样才能知道重合的多少。后面的区间尾部和前面的区间值越靠近，重合度越高
排序完之后的策略：如果一个头区间的值大于前面尾部区间，则需要用掉一个箭

static bool MyFuntion(vector<int> &a,vector<int> &b){
        return a[1]<b[1];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.empty()){
            return 0;
        }
        sort(points.begin(),points.end(),MyFuntion);
        int count=1;
        int temp=points[0][1];
        for(int i=1;i<points.size();i++){
            if(points[i][0]>temp){
                count++;
                temp=points[i][1];
            }
        }
        return count;
    }

406. Queue Reconstruction by Height(Medium)

这道题的意思就是，每个数组的第一个表示身高，第二个表示前面有几个大于或等于他身高的人，把这个队列弄对，每个数组都能对上。
比如：[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
排好序后就是：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]，每个数组的数字都是对的，比如[4,4]，身高为4，前面有四个人升高比他高，所以[4,4]在第5个位置上

思路：跟前面两道题一样，还是先排序，按照身高降序排序

 //对数组按照头降序，按照尾升序
    //这个排序算法可以好好学学
    static bool MyFunction1(vector<int> &a,vector<int> &b){
        return a[0]>b[0]||(a[0] == b[0] && a[1] < b[1]);
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        vector<vector<int>> res;
        sort(people.begin(),people.end(),MyFunction1);
        for(int i=0;i<people.size();i++){
            if(people[i][1]>=res.size()){
               res.push_back(people[i]);
            }else{
               res.insert(res.begin()+people[i][1],people[i]);
            }
        }
        return res;
    }

392. Is Subsequence (Medium)

这道题可以尝试使用动态规划求解

思路：双指针，你也可以理解为贪心吧
以后再碰到这一道题，试一试DP

bool isSubsequence(string s, string t) {
        int i=0;
        int j=0;
        while(i<s.size()&&j<t.size()){
            if(s[i]==t[j]){
                i++;
            }
            j++;
        }
        return i==s.size();
    }

763. Partition Labels (Medium)

思路：本质上还是数组前后重合的贪心算法
首先每一个出现的char都有对应的最开始位置和最后位置，记为[head,tail]
每次循环更新tail，不用head，因为head永远是第一个最小
分割的条件就是tail<下一个head，这样可以算出间隔，然后将head置为当前head，tail继续更新成为最大
最后结束循环还要进行push_back一次

vector<int> partitionLabels(string S) {
        vector<int> res;
        int min=S.find_first_of(S[0]);
        int tail=S.find_last_of(S[0]);
        int head=0;
        for(auto ch:S){
            head=S.find_first_of(ch);
            if(tail<head){
                res.push_back(tail-min+1);
                min=head;
            }
            tail=tail>(S.find_last_of(ch))?tail:S.find_last_of(ch);
        }
        res.push_back(tail-min+1);
        return res;
    }