代码随想录训练营第三十一天｜贪心算法：理论基础，455.分发饼干，376. 摆动序列，53. 最大子序和

最新推荐文章于 2024-11-06 04:54:58 发布

ababababyyyy

最新推荐文章于 2024-11-06 04:54:58 发布

阅读量43

点赞数

文章标签： c++ Powered by 金山文档

本文链接：https://blog.csdn.net/ababababyyyy/article/details/129317872

版权

文章介绍了三道LeetCode上的编程题目，包括分发饼干的解决方案，它涉及排序和贪心算法；摆动序列的解法，利用动态规划找到最长的摆动子序列；以及最大子序和问题，展示了两种不同的解决思路，一种超时，另一种运用动态规划达到线性时间复杂度。

摘要由CSDN通过智能技术生成

455.分发饼干

题目链接：https://leetcode.cn/problems/assign-cookies/

代码：

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int num = 0;
        int index = g.size()-1;//胃口
        for(int i = s.size() -1 ; i >= 0;i-- )
        {
            while(index >= 0 && s[i] < g[index])
                index--;
            if(index >= 0 && s[i] >= g[index])
            {
                num++;
                index--;
            }
        }
        return num;
    }
};

没审题导致进了死胡同：“如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足” 就是说就算大那也只给一个孩子

376. 摆动序列

题目链接：https://leetcode.cn/problems/wiggle-subsequence/

代码：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size() < 2)
            return 1;
        int max = 1;
        int tmp = nums[1] - nums[0];
        int count = 2;
        if(tmp == 0)
            count = 1;
        int pre = 2;
        int mid;
        while(pre < nums.size())
        {
            while(pre < nums.size() && nums[pre] == nums[pre-1])
                pre++;
            if(pre >= nums.size())
                break;
            mid = nums[pre] - nums[pre-1];
            if(mid * tmp < 0)
                count++;
            else
            {
                if(mid * tmp == 0)
                    count ++;
                if(count > max)
                    max = count;
            }
            tmp = mid;
            pre++;
        }
        if(count > max)
            max = count;
        return max;
    }
};

好暴力的解法。。一直在调试

53. 最大子序和

题目链接：https://leetcode.cn/problems/maximum-subarray/submissions/

代码：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max = INT_MIN;
        int sum = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            for(int j = i ; j < nums.size(); j++)
            {
                sum = sum_1(nums,i,j,0);
                if(sum > max)
                    max = sum;
            }
        }
        return max;
    }
    int sum_1(vector<int> nums,int left,int right,int sum)
    {
        for(int i = left ; i <=right ;i++)
        {
            sum += nums[i];
        }
        return sum;
    }
};

这个写法很简单但是时间复杂度很高最后超时了

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

关键就是连续和，所以当前“连续和”为负数的时候立刻放弃将sum重置，这样的话遍历一次就找到了