贪心算法(一)

🖊作者 : D. Star.
📘专栏 : 算法小能手
😆今日提问 : 国庆去哪里打卡了呢？
😆今日分享 : 武功山风景打卡–双云海

刚开始听到这个名称的时候,心里充满疑惑。心想：咋还有那么奇葩的名字，说的跟人一样…了解了它的核心思想后，我发现这个名字很符合它的特性。

🌻贪心算法的思想

贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。就像人一样，贪心时是顾不上大局的，只能看见眼前的利益，将自己的利益最大化。

🌻贪心算法的基本思路

从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。当达到算法中的某一步不能再继续前进时，算法停止。

该算法存在问题：

1. 不能保证求得的最后解是最佳的；

2. 不能用来求最大或最小解问题；

3. 只能求满足某些约束条件的可行解的范围。

📖给大家讲一个小故事理解一下吧~

• 从前有一只小海龟在一座孤岛上，和他的兄弟姐妹们刚从蛋里孵化出来，正准备爬到海里觅食。这时候，海龟妈妈说，谁第一个下海的，有零食大礼包奖励哦~

• 假设小海龟们可以爬1分钟/米，全长10米的路程，最优解是10分钟不停歇的爬完。

• 刚开始，小海龟们都兴致高昂，对零食大礼包势在必得。但是没爬一会儿，就有海龟放弃挣扎了等着晚上涨潮再下海，有的海龟则是一直赶路。咱们的小海龟哭着叫累呀，没办法，他在前进和摆烂中间，选择了摆烂一小会儿，前进一大步的策略。他休息10s，爬1分钟。最终他虽然不是第一，但整体来说，也是名列前茅的。
  分析：上面的小故事中，小海龟在考虑到自身条件的情况下，选择了贪心解法，满足了自身的最大利益，虽然不是最快的，但是也达到了下海的目的并且速度也不差。

📖再来个题目，理解一下吧~

第一题：力扣的860题

力扣的860题

题目：

• 在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
• 每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
• 注意，一开始你手头没有任何零钱。
  给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：

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

示例 2：

输入：bills = [5,5,10,10,20]
输出：false
解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false。

🔎解题思路：

---

🔎具体代码如下：

public static boolean lemonadeChange2(int[] bills) {
        int five = 0;
        int ten = 0;
        for (int x : bills) {
            if (x == 5) {
                five++;
                continue;
            } else if (x == 10) {
                if (five == 0) return false;
                five--;
                ten++;
            } else if (x == 20) {
                if (five != 0 && ten != 0) {
                    five--;
                    ten--;
                } else if (five >= 3) {
                    five -= 3;
                } else return false;
            }
        }
        return true;
    }

🔎总结：

我觉得这个题目 巧在 5元、10元、20元都是纸票子， 难在 20元有两种匹配方式。而10元+5元的才是最优配对方式。这个题目我自己做的时候，想复杂了。想不到这种又简便又通透的方法，真心崇拜贪心算法~

---

第二题：力扣的2208题

力扣的2208题

题目 ：

• 给你一个正整数数组 nums 。每一次操作中，你可以从 nums 中选择 任意 一个数并将它减小到 恰好 一半。（注意，在后续操作中你可以对减半过的数继续执行操作）
• 请你返回将 nums 数组和 至少 减少一半的 最少 操作数。

示例1:

输入：nums = [5,19,8,1]
输出：3
解释：初始 nums 的和为 5 + 19 + 8 + 1 = 33 。
以下是将数组和减少至少一半的一种方法：
选择数字 19 并减小为 9.5 。
选择数字 9.5 并减小为 4.75 。
选择数字 8 并减小为 4 。
最终数组为 [5, 4.75, 4, 1] ，和为 5 + 4.75 + 4 + 1 = 14.75 。
nums 的和减小了 33 - 14.75 = 18.25 ，减小的部分超过了初始数组和的一半，18.25 >= 33/2 = 16.5 。
我们需要 3 个操作实现题目要求，所以返回 3 。
可以证明，无法通过少于 3 个操作使数组和减少至少一半。

示例2：

输入：nums = [3,8,20]
输出：3
解释：初始 nums 的和为 3 + 8 + 20 = 31 。
以下是将数组和减少至少一半的一种方法：
选择数字 20 并减小为 10 。
选择数字 10 并减小为 5 。
选择数字 3 并减小为 1.5 。
最终数组为 [1.5, 8, 5] ，和为 1.5 + 8 + 5 = 14.5 。
nums 的和减小了 31 - 14.5 = 16.5 ，减小的部分超过了初始数组和的一半， 16.5 >= 31/2 = 15.5 。
我们需要 3 个操作实现题目要求，所以返回 3 。
可以证明，无法通过少于 3 个操作使数组和减少至少一半。

🔎解题思路：

)

🔎具体代码如下：

public int halveArray(int[] nums) {
        //题目的意思是说，通过减半操作，减半后的数组和要比原数组小，并且小一半及以上
        PriorityQueue<Double> heap = new PriorityQueue<>((a,b) -> b.compareTo(a));//大根堆
        double sum = 0.0;
        int number = 0;
        //计算原数组和
        for(int x:nums){
            heap.offer((double)x);
            sum+=x;
        }
        sum/=2.0;
        //判断sum<=0时，满足减少一半
        while(sum>0){
            double t = heap.poll()/2.0;//将最大的数字拿出来/2，
            number++;
            heap.offer(t);//再塞回去
            sum-=t;//将sum减去少掉的部分
        }
        return number;
    }

🔎总结：

我做这个题目的时候，觉得最难搞的就是 数据类型问题 ，原数组是整型，而减半之后就有可能是小数（double）了，我就想着如何将原数组复制出一个新的double数组，但是后面每次减半，我都要排列一下数组的大小顺序，导致我写的代码 超出了时间限制 。看了老师给的贪心解法后，直呼牛逼。由于对Java的不熟悉，不晓得还有一个PriorityQueue（自动排序）的数组结构，这个结构最牛逼的地方就是它可以根据我们的需要 自动排序，顶端的就是最大的数字！！！真的，你懂我的心情嘛？省了我好多事儿！！！

PriorityQueue的用法：
最大的优势就是：可插入，可移出，并且可以在插入常量的同时自动排序
创建一个降序数组：PriorityQueue<数据类型> 名称 = new PriorityQueue((a,b) -> b.compareTo(a)) //b<a
创建一个升序数组：PriorityQueue<数据类型> 名称 = new PriorityQueue((a,b) -> a.compareTo(b)) //a<b

第三题：力扣的179题

力扣的179题

题目:
给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。

示例 1：

输入：nums = [10,2]
输出：“210”

示例 2：

输入：nums = [3,30,34,5,9]
输出：“9534330”

解题思路：

具体代码如下：

 public String largestNumber(int[] nums) {
        int n = nums.length;//数组长度
        String[] arr = new String[n];//先建立一个字符串数组
        //将整型数组的内容全部拷贝到arr中
        for (int i = 0; i < n; i++) {
            arr[i] = "" + nums[i];
        }
        //排序
        Arrays.sort(arr, (a, b) -> {
            return (b + a).compareTo(a + b);
        });
        //提取结果
        StringBuffer str = new StringBuffer();
        for (int i = 0; i < n; i++) {
            str.append(arr[i]);//将字符串中的数字连接起来
        }
        //返回
        if (nums[0] == 0) return "0";
        return str.toString();
    }

总结：

这题的难点，我认为在于如何将“最大的”那个数字移到前面（这里的最大不是指数字值最大，而是使得这一串数字最大的 数字）。而解题最巧妙的点，在于Arrays.sort()这个排列我们可以将两个数字连接比较连接后的阿斯科码值，将大的排序放在前面。最后再用StringBuffer将这些字符串连接起来。

---

感谢家人的阅读,若有不准确的地方 欢迎在评论区指正!

家人们,点个再走呗~