贪心算法

 

力扣455.分发饼干

方法1：排序+贪心

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int g1=g.size()-1;
        int s1=s.size()-1;
        int res=0;
        while(g1>=0&& s1>=0)
        {
            if(s[s1]>=g[g1])  //当前饼干满足当前孩子
            {
                res++;
                g1--;
                s1--;
            }
            else
            {
                g1--; //找下一个孩子
            }
        }
        return res;
    }
};

力扣392判断子序列

方法1：贪心

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int s1=s.size();
        int t1=t.size();
        if(s1==0)
            return true;
        if(s1>t1)
            return false;
        int i=0,j=0;
        while(i<t1 && j<s1)
        {
            if(t[i]==s[j])
            {
                i++;
                j++;
            }
            else
            {
                i++;
            }
        }
        if(j==s1)
            return true;
        else return false;
    }
};

力扣435 无重叠区间

方法1：动态规划

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.empty()) {
            return 0;
        }
        
        sort(intervals.begin(), intervals.end(), [](const auto& u, const auto& v) {
            return u[0] < v[0];
        });

        int n = intervals.size();
        vector<int> f(n, 1);
        for (int i = 1; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                if (intervals[j][1] <= intervals[i][0]) {
                    f[i] = max(f[i], f[j] + 1);
                }
            }
        }
        return n - *max_element(f.begin(), f.end());
    }
};

方法2：贪心

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.empty()) {
            return 0;
        }
        
        sort(intervals.begin(), intervals.end(), [](const auto& u, const auto& v) {
            return u[1] < v[1];
        });

        int n = intervals.size();
        int right = intervals[0][1];
        int ans = 1;
        for (int i = 1; i < n; ++i) {
            if (intervals[i][0] >= right) {
                ++ans;
                right = intervals[i][1];
            }
        }
        return n - ans;
    }
};