贪心算法（贪婪算法）

贪心算法的简单介绍：

贪心算法的核心思想是寻找最优解的问题，但它得出的解却不一定是最有解。因为贪心算法是把问题分成若干个子问题，在子问题中寻找最优解，这样得出的解只是局部最优解，并未考虑长远，因此累加起来可能并不是最优解，只能看成近似最优。

例如上图，根据贪心算法思想，从v1到v4的最短路径是 v1 -> v3 -> v4，因为贪心永远考虑局部最优，在有负边的情况下得出错误解。

贪心算法的例子：

其实之前学过的Dijkstra 、Prim、Kruskal、选择排序等算法都使用了贪心算法的思想。每次循环找局部最优。

贪心算法是一种在每一步选择中都采取在当前状态下最好或最优(即最有利)的选择，从而希望导致结果是最好或最优的算法。这种算法通常用于求解优化问题，如最小生成树、背包问题等。

下面我们来看一道例题

例题：零钱兑换Ⅱ（Leetcode518）

这道题有两种解法：①递归（暴力解法）  ②动态规划

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;

/**
 * 518. 零钱兑换 II
 */
public class Leetcode518 {

    public int change(int amount, int[] coins) {
        return rec(0, coins, amount, new LinkedList<>(), true);
    }

    /**
     * 求凑成剩余金额的解的个数
     *
     * @param index     当前硬币索引
     * @param coins     硬币面值数组
     * @param remainder 剩余金额
     * @param stack
     * @param first
     * @return 解的个数
     */
    public int rec(int index, int[] coins, int remainder, LinkedList<Integer> stack, boolean first) {
        //首次调用没有进行组合硬币操作
        if (!first) {
            //拿到当前正在处理的硬币
            stack.push(coins[index]);
        }
        //remainder < 0, 无解
        int count = 0;
        if (remainder < 0) {
            print("无解", stack);
        } else if (remainder == 0) {
            //remainder == 0, 有解
            print("有解", stack);
            count = 1;
        } else {
            //remainder > 0, 继续递归
            for (int i = index; i < coins.length; i++) {
                count += rec(i, coins, remainder - coins[i], stack, false);
            }
        }
        if (!stack.isEmpty()) {
            stack.pop();
        }
        return count;
    }

    public static void main(String[] args) {
        Leetcode518 leetcode = new Leetcode518();
        System.out.println(leetcode.change(5, new int[]{1, 2, 5}));
    }

    private static void print(String prompt, LinkedList<Integer> stack) {
        //定义一个ArrayList<Integer>类型的变量print，并初始化它为空。
        ArrayList<Integer> print = new ArrayList<>();
        //获取stack列表的反向迭代器。这意味着我们可以从列表的最后一个元素开始迭代。
        ListIterator<Integer> iterator = stack.listIterator(stack.size());
        while (iterator.hasPrevious()) { //使用while循环和ListIterator的hasPrevious方法，当还有前面的元素时，循环将继续。
            //在循环体内，使用ListIterator的previous方法获取 上一个元素（即最近添加到列表的元素）并将其添加到print列表中。
            print.add(iterator.previous());
        }
        System.out.println(prompt + print);
    }
}

/*
 * 递归过程分析    参数一：代表正在处理的硬币   参数二：剩余金额
 * 这是一个多路递归 慢慢来
 * 先分析循环里的递归（分析大概的架子），不要一条路一直分析下去
 * rec(1,5)
 *       rec(1,4)
 *        /  rec(1,3)
 *        /   /  rec(1,2)
 *        /   /   /  rec(1,1)
 *        /   /   /    / rec(1,0) 1
 *        /   /   /    / rec(2,-1) 0
 *        /   /   /    / rec(5,-4) 0
 *        /   /   /  rec(2,0)  1
 *        /   /   /  rec(5,-3) 0
 *        /   /  rec(2,1)        //注意：这里index从2分硬币开始，不会与前面的1分硬币组合
 *        /   /   /  rec(2,-1) 0
 *        /   /   /  rec(5,-4) 0
 *        /   /  rec(5,-2) 0
 *        /  rec(2,2)
 *        /   /  rec(2,0) 1
 *        /   /  rec(5,-3) 0
 *        /  rec(5,-1) 0
 *       rec(2,3)
 *        /  rec(2,1)
 *        /   /  rec(2,-1) 0
 *        /   /  rec(5,-4) 0
 *        /  rec(5,-2) 0
 *       rec(5,0) 1
 * */

运行效果：

从以上代码看，这样递归效率特别低，递归的规模很大，我们可以适当地优化一下。

从我们的生活经验来分析，硬币组合从小到大来组合是更容易产生无解的情况，如果从大的硬币开始组合无解的情况会更少。

public static void main(String[] args) {
        Leetcode518 leetcode = new Leetcode518();
        int count = leetcode.change(5, new int[]{5, 2, 1});
        //int count = leetcode.change(5, new int[]{1, 2, 5});
        System.out.println(count);
    }

/*
* rec(5,5)
*       rec(5,0) 1
*       rec(2,3)
*           rec(2,1)
*               rec(2,-1) 0
*               rec(1,0) 1
*           rec(1,2)
*               rec(1,1)
*                   rec(1,0) 1
*       rec(1,4)
*           rec(1,3)
*               rec(1,2)
*                   rec(1,1)
*                       rec(1,0) 1
* */

运行效果：

由此可见，换个顺序，递归规模减少了很多。

我们再来看一道例题

例题2：零钱兑换（Leetcode322）

这题的解法和上一题差不多，还是先上暴力解法

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 322. 零钱兑换
 */
public class Leetcode322 {

    static int min = -1;
    public int coinChange(int amount, int[] coins) {
        rec(0, coins, amount, new AtomicInteger(-1), new LinkedList<>(), true);
        return min;
    }

    /**
     * 求凑成剩余金额的解的个数
     * @param index     当前硬币索引
     * @param coins     硬币面值数组
     * @param remainder 剩余金额
     * @param stack
     * @param first
     * @return 解的个数
     */
    //count代表某一组合 钱币的总数
    public void rec(int index, int[] coins, int remainder, AtomicInteger count, LinkedList<Integer> stack, boolean first) {
        //首次调用没有进行组合硬币操作
        if (!first) {
            //拿到当前正在处理的硬币
            stack.push(coins[index]);
        }
        count.getAndIncrement();  //count++
        //remainder > 0, 继续递归
        if (remainder > 0) {
            for (int i = index; i < coins.length; i++) {
                rec(i, coins, remainder - coins[i], count, stack, false);
            }
        } else if (remainder == 0) {
            //remainder == 0, 有解
            System.out.println(stack);
            if(min == -1){
                min = count.get();
            }else{
                min = Integer.min(min, count.get());
            }
        }
        count.getAndDecrement();  //count--
        if (!stack.isEmpty()) {
            stack.pop();
        }
    }

    public static void main(String[] args) {
        Leetcode322 leetcode = new Leetcode322();
        //int count = leetcode.change(5, new int[]{5, 2, 1});
        //int count = leetcode.coinChange(5, new int[]{1, 2, 5});
        int count = leetcode.coinChange(41, new int[]{25, 10, 5, 1});
        //int count = leetcode.coinChange(21, new int[]{15, 10, 1});
        System.out.println(count);
    }

    private static void print(String prompt, LinkedList<Integer> stack) {
        //定义一个ArrayList<Integer>类型的变量print，并初始化它为空。
        ArrayList<Integer> print = new ArrayList<>();
        //获取stack列表的反向迭代器。这意味着我们可以从列表的最后一个元素开始迭代。
        ListIterator<Integer> iterator = stack.listIterator(stack.size());
        while (iterator.hasPrevious()) { //使用while循环和ListIterator的hasPrevious方法，当还有前面的元素时，循环将继续。
            //在循环体内，使用ListIterator的previous方法获取 上一个元素（即最近添加到列表的元素）并将其添加到print列表中。
            print.add(iterator.previous());
        }
        System.out.println(prompt + print);
    }

}

这样写上去在leetcode上会超时，效率太低了。

再来看一下贪心解法，贪心算法有可能会得出错误的解，不过贪心算法适用于正常的货币组合，货币不会出现比较恶心的面值  比如  15  10  1  ...  当我们要组成20的时候。

思路：我们需要准备两个变量，①remainder（剩余金额） ②count（记录硬币个数）

public int coinChange(int amount, int[] coins) {    //15  10    假设要凑够20
        //每次循环找到当前最优解：面值最大的硬币，它凑出来的硬币数最小
        int remainder = amount;  //20
        int count = 0;
        for (int coin : coins) { 
            while (remainder > coin) {  // coin:15  当剩余金额小于当前硬币面值，不会执行减钱操作
                remainder -= coin;   // 5
                count++; //1
            }
            if (coin == remainder) {
                remainder = 0;
                count++;
                break;
            }
        }
        //因此remainder 只能存在大于或等于0这两种情况
        if (remainder > 0) {
            return -1;
        } else {
            return count;
        }
    }