《录鼎记》——贪心算法part01

今日任务：

• 理论基础

• 455.分发饼干

• 376. 摆动序列

• 53. 最大子序和

一、理论基础

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

贪心算法一般分为如下四步：

• 将问题分解为若干个子问题
• 找出适合的贪心策略
• 求解每一个子问题的最优解
• 将局部最优解堆叠成全局最优解

二、分发饼干

力扣题目链接 (opens new window)

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

思路：所有的事物分为两个，一个是胃口，一个是饼干尺寸。我们要做的二就是用有限的饼干尺寸去满足更更多的胃口。为了达成这一目标，最优解就是用大尺寸的饼干喂给大的胃口，充分利用饼干的尺寸，避免浪费。

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

    }
};

这里用了index记录数组中元素的多少，在循环中避免了双循环。

在做题的时候我在想，为什么不能从小到大遍历呢，然后就写了下面的代码：

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

    }
};

结果是报错的，原因是什么，因为我们的index指针是不动的，如果胃口的最小值大于饼干的最小值，那么指针一直不动，导致错误。

但实际上只要把循环顺序调换，让小饼干循环，满足小胃口。

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

就可以解决问题。

代码随想录 (programmercarl.com)

三、摆动序列

力扣题目链接 (opens new window)

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。

例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

思路：本题要求两个数的差值是正负交替的，所以就说明如果存在某几个节点之间是单调坡度，则在他们之间的一些节点就不是满足条件的节点，需要有局部峰值

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()<=1) return nums.size();
        int curdiff=0;
        int prediff=0;
        int result=1;
        for(int i=0;i<nums.size()-1;i++){
            curdiff=nums[i+1]-nums[i];
            if((prediff<=0&&curdiff>0||prediff>=0&&curdiff<0)){
                result++;
                prediff =curdiff;
            }
        }
        return result;

    }
};

本题其实在思考的过程中很难一次想到位，其中要考虑三种情况：

1. 情况一：上下坡中有平坡
2. 情况二：数组首尾两端
3. 情况三：单调坡中有平坡

思路2：动态规划

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int dp[1005][2];
        memset(dp,0,sizeof dp);
        dp[0][0]=dp[0][1]=1;
        for(int i=1;i<nums.size();i++){
            dp[i][0]=dp[i][1]=1;
            for(int j=0;j<i;++j){
                if(nums[j]>nums[i]){
                    dp[i][1]=max(dp[i][1],dp[j][0]+1);
                }
            }
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]){
                   dp[i][0]= max(dp[i][0],dp[j][1]+1); 
                }
                
            }
            
        }return max(dp[nums.size()-1][0],dp[nums.size()-1][1]);

    }
};

四、最大子序和

力扣题目链接 (opens new window)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0, maxAns = nums[0];
        for (const auto &x: nums) {
            pre = max(pre + x, x);
            maxAns = max(maxAns, pre);
        }
        return maxAns;
    }
};

这是一个极其简洁的代码，它的原理是，pre存储累加和，但是如果不是最大值的时候，maxans不会改变，同时如果此时的累加和是负的，说明对于整体的累加和是副作用，所以pre用max函数规避了这个坑。

但这有点过于简洁，为了更好地体现贪心，写一下代码：

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

    }
};

若count为正数，则一直存下去，如果count>result则更新result

动态规划：

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 =dp[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;

    }
};

这其实和第一段代码有异曲同工之处。

前两天有笔试和面试，终于回来补作业了