贪心算法相关 455-分发饼干 135-分发糖果 605-种花问题

TODO

概念:

https://cloud.tencent.com/developer/article/1092766

  贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。 贪心算法不是对所有问题都能得到整体最优解,关键是贪心策略的选择,选择的贪心策略必须具备无后效性,即某个状态以前的过程不会影响以后的状态,只与当前状态有关

基本思路

  1. 建立数学模型来描述问题;
  2. 把求解的问题分成若干个子问题;
  3. 对每一子问题求解,得到子问题的局部最优解;
  4. 把子问题的解局部最优解合成原来解问题的一个解。

相关题目:

  • 455-分发饼干 
  • 135-分发糖果 
  • 605-种花问题
  • 435-无重叠区间

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.
 

提示:

1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1

解答:

//g-小孩胃口值
//s-饼干尺寸
int findContentChildren(vector<int>& g, vector<int>& s) 
{
    if (g.size() == 0 || s.size() == 0)
        return 0;
    sort(g.begin(), g.begin() + g.size());
    sort(s.begin(), s.begin() + s.size());

    int cookieIdx = 0;
    int i = 0;
    while (cookieIdx < s.size() && i < g.size())
    {
        if (s[cookieIdx] >= g[i])
        {
            i++;
            cookieIdx++;
            continue;
        }

        cookieIdx++;
    }
    return i;
}

135-分发糖果 

题目:

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

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

每个孩子至少分配到 1 个糖果。
相邻的孩子中,评分高的孩子必须获得更多的糖果。
那么这样下来,老师至少需要准备多少颗糖果呢?

示例 1:

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

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

解答:

注意:第二次遍历时,要判断下当前元素的值是否满足,不然会导致第一次遍历时置上的值被重置,会导致最终结果错误。

#include <numeric>
int candy(vector<int>& ratings) 
{
    //记录每个人的糖果个数,最少一个
    vector<int> childrenCandy(ratings.size(), 1);
    for (int i = 1; i < ratings.size(); i++)
    {
        if (ratings[i] > ratings[i - 1])
            childrenCandy[i] = childrenCandy[i - 1] + 1;
        
    }
    for (auto val:childrenCandy)
        cout << val << endl;
    cout << endl;
    for (int i = ratings.size()-1; i > 0; i--)
    {
        if (ratings[i - 1] > ratings[i])
            childrenCandy[i - 1] = (childrenCandy[i - 1] > (childrenCandy[i] + 1))? childrenCandy[i-1] :(childrenCandy[i] + 1);
    }
    for (auto val : childrenCandy)
        cout << val << endl;
    cout << endl;

    return accumulate(childrenCandy.begin(), childrenCandy.end(), 0);
}

605-种花问题

题目:

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

给定一个花坛(表示为一个数组包含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
注意:

数组内已种好的花不会违反种植规则。
输入的数组长度范围为 [1, 20000]。
n 是非负整数,且不会超过输入数组的大小。

解答:

解答一:

遍历一遍vector,然后找到符合要求的位置,计数++,然后将该位置置为1,表示种了花

bool canPlaceFlowers(vector<int>& flowerbed, int n) 
{
    if (flowerbed.size() == 0)    //当数组为空时,n=0时返回true
        return (n == 0);

    int canDo = 0;//可以种植的个数
    for (int i = 0; i < flowerbed.size(); i++)
    {
        if (i == 0 && flowerbed[i] == 0 && (i+1)<flowerbed.size() && flowerbed[i + 1] == 0)
        {
            canDo++;
        }
        if (i == flowerbed.size() - 1 && (i - 1) > 0 && flowerbed[i-1]==0)
        {
            canDo++;
            if (canDo >= n)
                return true;
        }
        if ((i - 1) > 0 && (i + 1) < flowerbed.size())
        {
            if (flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0 && flowerbed[i] == 0)
            {
                flowerbed[i] = 1;
                canDo++;
            }
        }
    }

    return (canDo >= n);
}

看题解后,发现思路一样(题解给的Java代码会越界吧?i<s.len,但是判断中出现了i+1 ?),但是判断条件写的较好,修改代码如下,

//从左到右扫描,如果该元素为0且左右都为0,则加1,
//如果第一个元素为0,且第二个元素为0,则加1
//如果倒数第二个元素为0,且最后一个元素为0,则加1
//中间如果超过了n,直接返回true
bool canPlaceFlowers2(vector<int>& flowerbed, int n)
{
    int canDo = 0;
    int len = flowerbed.size();
    for (int i = 0; i < len; i++)
    {
        if (flowerbed[i] == 0)
        {
            //i=0时,如果只有一个元素也成立
            if (i == 0 &&((i + 1 == len) || (i + 1 < len) && flowerbed[i + 1] == 0))
            {
                flowerbed[i] = 1;
                canDo++;
                if (canDo >= n)return true;
                continue;
            }
            if (i == len - 2 && flowerbed[i + 1] == 0)
            {
                flowerbed[i] = 1;
                canDo++;
                if (canDo >= n)return true;
                continue;
            }
            if ((i - 1) >= 0 && (i + 1) < len && flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0)
            {
                flowerbed[i] = 1;
                canDo++;
                if (canDo >= n)return true;
                continue;
            }
        }
    }
    return canDo >= n;
}

然后看了排名靠前的代码,在vector前后各插入一个0,这样就不用判断边界条件了,直接找连续3个0的个数,代码如下:

bool canPlaceFlowers3(vector<int>& flowerbed, int n)
{
    flowerbed.insert(flowerbed.begin(), 0);
    flowerbed.insert(flowerbed.end(), 0);
    int canDo = 0;
    int len = flowerbed.size();
    for (int i = 1; i < len - 1; i++)
    {
        if (flowerbed[i - 1] == 0 && flowerbed[i] == 0 && flowerbed[i + 1] == 0)
        {
            flowerbed[i] = 1;
            canDo++;
            if (canDo >= n)return true;
            
        }
    }

    return canDo >= n;
}
原文地址:https://www.cnblogs.com/zyk1113/p/14016245.html