leetcode刷题——算法（3）:贪心思想

贪心思想：保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。

		备注
1. 分配饼干	Ok，修改更简洁
2. 不重叠的区间个数（2.14）	一开始未做出	※
3. 投飞镖刺破气球	Ok，解法类上
4. 根据身高和序号重组队列	一开始未做出	※
5. 买卖股票最大的收益	思考后做出	※
6. 买卖股票的最大收益 II	解法可简化
7. 种植花朵	解法可简化
8. 判断是否为子序列	修改后做出Ok 注意空字符串
9. 修改一个数成为非递减数组	思考后做出	※
10. 子数组最大的和	修改后做出	※
11. 分隔字符串使同种字符出现在一起	一开始未做出	※

1. 分配饼干

455. Assign Cookies (Easy)

https://leetcode-cn.com/problems/assign-cookies/submissions/

修改更简洁

2. 不重叠的区间个数

435. Non-overlapping Intervals (Medium)

https://leetcode-cn.com/problems/non-overlapping-intervals/submissions/

将区间右边界从小到大排序

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

3. 投飞镖刺破气球

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

https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/submissions/

解法类上

4. 根据身高和序号重组队列

406. Queue Reconstruction by Height(Medium)

https://leetcode-cn.com/problems/queue-reconstruction-by-height/solution/gen-ju-shen-gao-zhong-jian-dui-lie-by-leetcode/

先按身高->队列值排序，该策略可以递归进行：

1. 将最高的人按照 k 值升序排序，然后将它们放置到输出队列中与 k 值相等的索引位置上。
2. 按降序取下一个高度，同样按 k 值对该身高的人升序排序，然后逐个插入到输出队列中与 k 值相等的索引位置上。
3. 直到完成为止

class Solution {
public:
    static bool cmp(vector<int> l,vector<int> r){
        if(l[0]!=r[0]) return l[0]>r[0];
        else return l[1]<r[1];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        int n=people.size();
        sort(people.begin(),people.end(),cmp);
        vector<vector<int>> res(n);
        for(int i=0;i<n;i++){
            int index=people[i][1];
            for(int j=i;j>index;j--)
                res[j]=res[j-1];
            res[index]=people[i];
        }
        return res;
    }
};

5. 买卖股票最大的收益

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/submissions/

6. 买卖股票的最大收益 II

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/submissions/

解法可简化

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int res=0;
        for(int i=1;i<prices.size();i++){
            if(prices[i]>prices[i-1])
               res+=prices[i]-prices[i-1];
        }
        return res;
    }
};

7. 种植花朵

https://leetcode-cn.com/problems/can-place-flowers/submissions/

605. Can Place Flowers (Easy)

可简化

class Solution {
public:
    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
        int cnt=0;
        for(int i=0;i<flowerbed.size();i++){
            if(flowerbed[i]==1)  continue;
            int pre=(i==0)?0:flowerbed[i-1];
            int next=(i==flowerbed.size()-1)?0:flowerbed[i+1];
            if(pre==0&&next==0){
                flowerbed[i]=1;
                cnt++;
            } 
        }
        return cnt>=n;
    }
};

8. 判断是否为子序列

392. Is Subsequence (Medium)

https://leetcode-cn.com/problems/is-subsequence/submissions/

注意：字符串注意空字符串的情况

9. 修改一个数成为非递减数组

665. Non-decreasing Array (Easy)

https://leetcode-cn.com/problems/non-decreasing-array/

10. 子数组最大的和

53. Maximum Subarray (Easy)

https://leetcode-cn.com/problems/maximum-subarray/submissions/

细心！

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        if(n==0) return 0;
        int sum=nums[0],max=nums[0];
        for(int i=1;i<n;i++){
            if(sum<0) sum=nums[i];
            else sum+=nums[i];
            if(sum>max) max=sum;
        }
        return max;
    }
};

11. 分隔字符串使同种字符出现在一起

763. Partition Labels (Medium)

https://leetcode-cn.com/problems/partition-labels/submissions/

class Solution {
public:
    vector<int> partitionLabels(string S) {
        vector<int> res;
        int hst[26]={0};
        for(int i=0;i<S.size();i++)
           hst[S[i]-'a']=i;
        int start=0,end=start;
        for(int i=0;i<S.size();i++){
            if(hst[S[i]-'a']>end) end=hst[S[i]-'a'];
            if(end==i){
                res.push_back(end-start+1);
                start=i+1;
            }
        }
        return res;
    }
};