算法刷题Day 31 分发饼干+摆动序列+最大子序列和

Day 31 贪心算法

455. 分发饼干

分发饼干其实有很多种写法，但是下面这种贪心的解法是最好理解，也最好解释的

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(s.begin(), s.end());
        sort(g.begin(), g.end());

        int cnt = 0;

        auto sriter = s.rbegin();
        auto griter = g.rbegin();

        while (sriter != s.rend() && griter != g.rend())
        {
            if (*sriter >= *griter)
            {
                sriter++;
                cnt++;
            }
            griter++;
        }

        return cnt;
    }
};

我的其他解法

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 cnt = 0;

        for (int i = 0; i < g.size(); i++) {
            if (cnt < s.size() && g[i] <= s[cnt]) {
                cnt++;
            }
        }

        return cnt;
    }
};

376. 摆动序列

贪心算法

这道题用贪心算法要考虑的细节有很多。

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();

        int preDiff = 0, cnt = 1;

        for (int i = 0; i < nums.size() - 1; ++i)
        {
            int curDiff = nums[i + 1] - nums[i];
            if ((preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0))
            {
                cnt++;
                preDiff = curDiff;
            }
        }

        return cnt;
    }
};

动态规划

有点难（甚至涉及到了线段树），等后面二刷的时候再来学好了

53. 最大子序和

暴力解法

超时了

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int maxSum = INT_MIN;

        for (int i = 0; i < nums.size(); i++)
        {
            int sum = 0;

            for (int j = i; j < nums.size(); j++)
            {
                sum += nums[j];
                if (sum > maxSum)
                {
                    maxSum = sum;
                }
            }
        }

        return maxSum;
    }
};

贪心算法

贪心算法的代码写起来简单明了。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int maxSum = INT_MIN, sum = 0;

        for (int i = 0; i < nums.size(); ++i)
        {
            sum += nums[i];
            if (sum > maxSum)
            {
                maxSum = sum;
            }
            if (sum < 0) // 这一步是贪心的关键
            {
                sum = 0;
            }
        }

        return maxSum;
    }
};

动态规划

感觉内核跟贪心一样，只是实现起来比较绕一点。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.size() == 0) return 0;

        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        int result = nums[0];

        for (int i = 1; i < nums.size(); ++i)
        {
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            if (dp[i] > result)
            {
                result = dp[i];
            }
        } 

        return result;
    }
};