【算法：leetcode】贪心：455分配饼干、605种花、135分发糖果

【算法：leetcode】贪心

贪心

贪心的思想：让局部最优，从而达到全局最优

455分配饼干

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

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

示例 1:

输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。
示例 2:

输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/assign-cookies

贪心策略：g 和 s 从小到大进行比较，尽可能满足的匹配，进行输出
如果，饼干的大小大于孩子的饥饿值，则孩子进行加加；
如果，饼干的大小小于孩子的饥饿值，则饼干进行加加。

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

605种花

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。

示例 1：

输入：flowerbed = [1,0,0,0,1], n = 1
输出：true
示例 2：

输入：flowerbed = [1,0,0,0,1], n = 2
输出：false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/can-place-flowers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处

贪心策略：让花都尽可能的种上，然后与数字进行比较。
做题策略：分析能够种花的情况
1，| 0 |
2，| 0 0
3，0 0 |
4，0 0 0

class Solution {
public:
    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
        int z = 0;
        //特殊情况：n为0的时候，均满足
        if(n==0) return true;
        //边界问题要注意
        if(flowerbed.size()==0) return false;
        //第一种情况：| 0 |
   if(flowerbed.size()==1){
       if(flowerbed[0]==0 && n == 0)
       return true;
       else if(flowerbed[0] == 0 && n == 1)
       return true;
       else if(flowerbed[0] == 1 && n == 0)
       return true;
       else if(flowerbed[0] == 1 && n == 1)
       return false;
       else 
       return false;
   }
   for(int i = 0;i < flowerbed.size() ; i++){
       // 第二种情况：| 0 0 
       if(i==0){
           if(flowerbed[i] == 0 && flowerbed[i+1] == 0){
             flowerbed[i] = 1;
             z++;  
           }
       }
       // 第三种情况：0 0 |
       else if(i == flowerbed.size()-1 ){
           if(flowerbed[i] == 0 && flowerbed[i-1]==0){
                flowerbed[i] = 1;
                z++;
           }
       }
       // 第四种情况：0 0 0
       else if(flowerbed[i] == 0 ){
           if(flowerbed[i-1] == 0 && flowerbed[i+1] == 0){
               flowerbed[i] = 1;
               z++; 
           }
       }
       if(z == n) return true;
   }
   return false;
    }
};

135分发糖果

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

示例 1：

输入：[1,0,2]
输出：5
解释：你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例 2：

输入：[1,2,2]
输出：4
解释：你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/candy
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

贪心策略即为，在每次遍历中，只考虑并更新相邻一侧的大小关系。
做题策略：
1，从左往右进行遍历一遍
2，从右往左进行遍历一遍

class Solution {
public:
    int candy(vector<int>& ratings) {
    if(ratings.size() < 1){
        return 1;
    }else{
        //让num数组里面的值全为1
        vector<int> num(ratings.size(),1);
        for(int i = 1; i < ratings.size() ; i++){
            //从左往右看
            if(ratings[i] > ratings[i-1]){
                num[i] = num [i-1] + 1;
            }
        }
        for(int i = ratings.size() - 1; i > 0; i--){
            //从右往左看
            if(ratings[i-1] > ratings[i]){
                num[i-1] = max(num[i]+1,num[i-1]);
            }
        }
        return accumulate(num.begin(),num.end(),0);
    }
    }
    
};