【leetcode真题】贪心算法

通常同学们可能会认为贪心算法比较简单。确实，通常贪心算法的实现非常容易，但是，一个问题是否能够使用贪心算法，是一定要小心的。

问题1：分发饼干

原题

/// Greedy Algorithm
/// Serve most greedy children first
/// Time Complexity: O(nlogn)
/// Space Complexity: O(1)
class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {

        //从大到小排序
        sort(g.begin(), g.end(), greater<int>());
        sort(s.begin(), s.end(), greater<int>());

        int gi = 0, si = 0;  //两个索引跟踪两个数组
        int res = 0;
        while(gi < g.size() && si < s.size()){
            if(s[si] >= g[gi]){
                res ++;
                si ++;
                gi ++;
            }
            else
                gi ++;
        }

        return res;
    }
};

问题2：Is Subsequence

原题

/// Simulation
/// Time Complexity: O(len(s) + len(t))
/// Space Complexity: O(1)
class Solution {
public:
    bool isSubsequence(string s, string t) {

        int index = -1;
        //遍历子串
        for(char c: s){
            index = t.find(c, index + 1);
            if(index == string::npos) return false;
        }
        return true;
    }
};

贪心算法与动态规划的关系

问题3：Non-overlapping Intervals非重叠区间

Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
Note:
You may assume the interval’s end point is always bigger than its start point.
Intervals like [1,2] and [2,3] have borders “touching” but they don’t overlap each other.

Example 1:
Input: [ [1,2], [2,3], [3,4], [1,3] ]
Output: 1
Explanation: [1,3] can be removed and the rest of intervals are non-overlapping.

Example 2:
Input: [ [1,2], [1,2], [1,2] ]
Output: 2
Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.

Example 3:
Input: [ [1,2], [2,3] ]
Output: 0
Explanation: You don’t need to remove any of the intervals since they’re already non-overlapping.
NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

/// Dynamic Programming based on ending point
/// Time Complexity:  O(n^2)
/// Space Complexity: O(n)
class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {

        if(intervals.size() == 0)
            return 0;

        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){
            if(a[1] != b[1]) return a[1] < b[1];
            return a[0] < b[0];
        });

        //dp[i]表示使用intervals[0...i]的区间能构成的最长不重叠区间序列
        vector<int> dp(intervals.size(), 1);
        for(int i = 1 ; i < intervals.size() ; i ++)
            for(int j = 0 ; j < i ; j ++)
                if(intervals[i][0] >= intervals[j][1])
                    dp[i] = max(dp[i], 1 + dp[j]);

        return intervals.size() - *max_element(dp.begin(), dp.end());
    }
};

/// Greedy Algorithm based on ending point
/// Time Complexity:  O(n)
/// Space Complexity: O(n)
class Solution {
public:
    //贪心算法
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {

        if(intervals.size() == 0)
            return 0;

        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){
            if(a[1] != b[1]) return a[1] < b[1];
            return a[0] < b[0];
        });

        int res = 1;
        int pre = 0;
        for(int i = 1 ; i < intervals.size() ; i ++)
            if(intervals[i][0] >= intervals[pre][1]){
                res ++;
                pre = i;
            }

        return intervals.size() - res;
    }
};

到这里，算法这一模块也算是过了一遍了，下一个阶段，就是继续框架的学习，有时间再搞搞算法的题目做一下！希望疫情尽快结束，让我早日回学校（虽然我觉得在家还是挺好的），加油！！