算法通关第十七关青铜挑战——原来贪心如此简单(什么是贪心思想and经典例题分析)

大家好,我是怒码少年小码。

一转眼,又到了11月末尾了,莫名感觉今年真的很快。今天的主角是贪心。

贪心的思想非常不好解释,而且越使用权威的语言解释越难懂。而且做题的时候根据自己的理解可能直接做出来,但是非要解释一下怎么使用的贪心的话,就懵圈了。
一般涞水,贪心的题目没有固定的套路,一题一样,不过好在大部分的贪心算法题不是特别难

公认的贪心学习方法就是——直接上手,自我总结。因此,本篇将以经典题目的形式一点一点将思想渗透。

贪心思想

定义

指在对问题进行求解时,在每一步选择中都采取最好或者最优(即最有利)的选择,从而希望能够导致结果是最好或者最优的算法。

**注意:**贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解),但是都是相对近似(接近)最优解的结果。

性质

1. 最优子结构性质

最优子结构性质是指问题的最优解包含了其子问题的最优解。

也就是说,在使用贪心算法解决问题时,我们可以通过子问题的最优解来构建全局最优解。通过将问题分解为各个子问题,并以递归的方式解决子问题,最终可以获得整体的最优解。

假设我们需要购买一些商品,每个商品都有一个重量和价值。我们有一个限制总重量的背包,目标是在不超过背包容量的情况下,选择一些商品放入背包,使得背包中的商品总价值最大化。在这个问题中,如果我们知道每个商品的最佳选择,那么我们可以根据最佳选择逐步填充背包,最终得到最大总价值。这种问题的最优解可以通过子问题的最优解构建而来,具有最优子结构性质。

2. 贪心选择性质
贪心选择性质是指在每一步选择中,都采取当前最好的选择,而不考虑未来的影响。也就是说,我们每次做出局部最优的选择,希望这些局部最优解最终能够导致全局最优解。

继续以背包问题为例,假设我们在每一步都选择具有最大价值重量比的商品放入背包。这意味着我们每次选择贡献价值最大的商品,并且在剩余容量允许的情况下选择下一个商品,直到背包达到最大容量。这种贪心选择性质可以帮助我们获得一个近似的最优解,尽管在某些情况下可能不是全局最优解。


注意:在选择使用贪心算法解决问题时,必须确保问题满足这两个性质。

应用场景

  • 排序问题:选择排序、拓扑排序
  • 优先队列:堆排序
  • 赫夫曼压缩编码
  • 图里的Prim、Fruskal和Dijkstra算法
  • 硬币找零问题
  • 部分背包问题
  • 并查集的按大小或者高度合并问题或者排名
  • 任务调度部分场景
  • 一些复杂问题的近似算法

贪心例题

分发饼干

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

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

示例:

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

分析:这里既要满足小孩的胃口,也不要造成饼干尺寸的浪费。大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子,那么就应该优先满足胃口大的。这里的局部最优就是大饼干喂给胃口大的,充分利用饼干尺寸喂饱一个,全局最优就是喂饱尽可能多的小孩。

使用贪心策略,先将饼干数组和小孩数组排序。 然后从后向前遍历小孩数组,用大饼干优先满足胃口大的,并统计满足小孩数量就可以了。

算法通关第十七关青铜挑战——原来贪心如此简单(什么是贪心思想and经典例题分析)_第1张图片

public int findContentChildren(int[] g, int[] s) {
    Arrays.sort(g);
    Arrays.sort(s);
    int count = 0;
    int start = s.length - 1;
    //遍历孩子的胃口
    for(int i = g.length - 1 ; i >=0 ; i--){
        if(start >= 0 && g[i] <= s[start]){
            start--;
            count++;
        }
    }
    return count;
}

柠檬水找零

LeetCode 860:在柠檬水摊上,每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品,(按账单 bills 支付的顺序)一次购买一杯。每位顾客只买一杯柠檬水,然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零,也就是说净交易是每位顾客向你支付 5 美元。

注意,一开始你手头没有任何零钱。

给你一个整数数组 bills ,其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零,返回 true ,否则返回 false 。

示例:

  • 输入:bills = [5,5,5,10,20]
  • 输出:true

解释:

  • 前 3 位顾客那里,我们按顺序收取 3 张 5 美元的钞票。
  • 第 4 位顾客那里,我们收取一张 10 美元的钞票,并返还 5 美元。
  • 第 5 位顾客那里,我们找还一张 10 美元的钞票和一张 5 美元的钞票。
    由于所有客户都得到了正确的找零,所以我们输出 true。

分析:收钱找零的情况有三种:

  1. 如果给的是5,那么直接收下。
  2. 如果给的是10元,那么收下一个10,给出一个5,此时必须要有一个5才行。
  3. 如果给的是20,那么优先消耗一个10元,再给一个5元。假如没有10元,则给出3个5元。

第三种情况还要再分析:如果给的是20,那么优先消耗一个10元,再给一个5元;还是给出3个5元?

答: 肯定是有10就先给10,没有才给多个5。因为10只能给账单20找零,而5可以给账单10和账单20找零,5更万能!所以这里的局部最优就是遇到账单20,优先消耗美元10,完成本次找零。

这就是局部最优可以推出全局最优,代码如下:

public boolean lemonadeChange(int[] bills) {
    //仅代表5元和10元纸币的数量,而不是总金额
    int cash_5 = 0;
    int cash_10 = 0;
    for(int i = 0;i<bills.length;i++){
        if(bills[i]==5){
            cash_5++;
        }
        if(bills[i] == 10){
            cash_5--;
            cash_10++;
        }
        if(bills[i] == 20){
            if(cash_10 > 0){
                cash_10--;
                cash_5--;
            }else{
                cash_5 -= 3;
            }
        }
  //如果遍历这一位客户的钱之后,纸币数量需要为负数,则直接返回false
        if(cash_5 < 0 || cash_10 < 0) return false;
    }
    return true;
}

就像老爹说的那样:不要被事物的表面现象所迷惑,这题的关键是纸币的数量,而不是面值。

分发糖果

LeetCode 135:n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。你需要按照以下要求,给这些孩子分发糖果:

  • 每个孩子至少分配到 1 个糖果。
  • 相邻两个孩子评分更高的孩子会获得更多的糖果。
  • 请你给每个孩子分发糖果,计算并返回需要准备的 最少糖果数目

示例 1:

  • 输入:ratings = [1,0,2]
  • 输出:5
  • 解释:你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。

示例 2:

  • 输入:ratings = [1,2,2]
  • 输出:4
  • 解释:你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
    第三个孩子只得到 1 颗糖果,这满足题面中的两个条件。

分析:首先我们来看这个题是什么意思。假如有5个孩子,因为每个孩子至少一个糖果,所以一定要花出去的最少糖果是{1,1,1,1,1} 一共5个。

然后是相邻孩子评分更高的能获得更多的糖果。假如评分为{1,2,3,2},则最少花出去的糖果为{1,2,3,1},因为前三个评分在增加,则糖果必须递增,因此分别要发的糖果最少为{1,2,3}个,最后一个因为评分低了,所以我们给最少1个。

另外,假如评分相等,例如{1,2,2,2,2,},根据题目要求,则后面重复的都给一个的就行了,也就是分别给{1,2,1,1,1}个。

综上,我们可以根据题意从左向后依次比较,确定第一轮要预发的糖果数量,只要右边的比左边的大,就一直加1;如果右边比左边小,就设置为1 ,然后继续向右比较。结果如下:

算法通关第十七关青铜挑战——原来贪心如此简单(什么是贪心思想and经典例题分析)_第2张图片

此时有人就有疑问了,题目是要求相邻的孩子评分高的孩子必须获得更多的糖果,上面序列的后面几个评分为 4 、3、 2 但是得到的糖果却是一样的,那怎么办呢?

很简单, 我们在上面的基础上,再从右向左走一轮。如果左边的比右边的小,则不管。如果左边的比右边的大,则不是简单的加一,而是要在{i+1}的基础上,先加1再赋值给{i}。看例子:
最后四个评分为 {5 4 3 2 },第一轮结束之后应该发的糖果为left={2,1,1,1}。
如果当我们只考虑从右向左的时候,很显然:

  • 最后一个评分为2得到1个糖果
  • 倒数第二个评分为3,得到2个糖果
  • 倒数第三个评分为4,得到2+1=3个糖果
  • 倒数第四个评分为5,得到3+1=4个糖果

因此最后四个的right={4,3,2,1},接下来每个位置i我们只要从left[i]和right[i]中选最大就行了。不过这里我们其实不用两个数组,一个数组更新两次即可,首先从左向后给数组candyVec赋值,然后再从右向左更新数组元素,每次赋值之前先比较一下取max即可。如下图:

算法通关第十七关青铜挑战——原来贪心如此简单(什么是贪心思想and经典例题分析)_第3张图片

所以代码如下:

public int candy(int[] ratings) {
    int[] candyVec = new int[ratings.length];
    candyVec[0] = 1;
    for (int i = 1; i < ratings.length; i++) {
        if (ratings[i] > ratings[i - 1]) {
            candyVec[i] = candyVec[i - 1] + 1;
        } else {
            candyVec[i] = 1;
        }
    }
    for (int i = ratings.length - 2; i >= 0; i--) {
        if (ratings[i] > ratings[i + 1]) {
            candyVec[i] = Math.max(candyVec[i], candyVec[i + 1] + 1);
         }
    }
    int ans = 0;
    for (int s : candyVec) {
        ans += s;
    }
    return ans;
}

END

临近期末,好多没做,大伙见谅。

关注微信公众号:怒码少年。回复关键词【电子书】,领取多本计算机相关电子书

你可能感兴趣的:(算法学习,算法)