【算法 - 动态规划】找零钱问题Ⅰ-CSDN博客

本文链接：https://blog.csdn.net/weixin_46879314/article/details/136301542

在前面的动态规划系列文章中，关于如何对递归进行分析的四种基本模型都介绍完了，再来回顾一下：

从左到右模型 ：arr[index ...] 从 index 之前的不用考虑，只考虑后面的该如何选择 。
范围尝试模型 ：思考 [L ,R] 两端，即 开头和结尾 处分别该如何取舍。
样本对应模型 ：以 结尾位置 为出发点，思考两个样本的结尾都会产生哪些可能性。
业务限制模型 ：不能够明确的知道一个参数的变化范围，通过业务的限制找到 最差情况 进行估计。

接下来的几篇文章我们继续深挖动态规划的一些 优化策略。

通过前面文章的学习，相信小伙伴都能够根据不同模型的套路熟练的改出 严格表依赖 的动态规划版本了。

但有个问题？

记忆化搜索 和 严格 dp 表依赖 的时间复杂度一样，记忆化搜索的代码写起来容易，为什么还非要找到动态规划的 状态转移方程 ，进而修改成为严格表依赖关系的呢。接下来我们通过一道题目 揭晓答案 ！

找零钱问题Ⅰ

给定一个面值数组 arr ，其中的值均为无重复的正数，每一个值代表一种面值，张数无限。求能够组成 aim 的方法数是多少。

示例 1：

输入: arr = {1, 2} ，aim = 4 。

输出： 3

解释： 共三种组合方式

1 + 1 + 1 + 1 = 4
1 + 1 + 2 = 4
2 + 2 = 4

示例 2：

输入: arr = {1, 2, 5} ，aim = 6 。

输出： 5

解释： 共五种组合方式

1 + 1 + 1 + 1 + 1 + 1 = 6
1 + 1 + 1 + 1 + 2 = 6
1 + 1 + 2 + 2 = 6
2 + 2 + 2 = 6
1 + 5 = 6

首先我们依然采用最朴素的 暴力递归 来思考这道题目。

思路

这道题就是典型的 从左到右模型 ，因此，递归就可以按照在 arr[index ...]数组中，index 之前的不用考虑，只考虑后面的该如何选择 的思路来划分情况：

当前 index 下标对应的面值参与组合，选择任意张数，之后能有多少种情况；
当前 index 下标对应的面值 不参与 组合，选择任意张数，之后能有多少种情况。

因为要求总的情况，因此要返回这两种情况的总和。

代码

public static int coinsWay(int[] arr, int aim) {
    if (arr == null || arr.length == 0 || aim < 0) {
        return 0;
    }
    return process(arr, 0, aim);
}

public static int process(int[] arr, int index, int rest) {
    if (index == arr.length) { 
        return rest == 0 ? 1 : 0;
    }
    int ways = 0;
    for (int zhang = 0; zhang * arr[index] <= rest; zhang++) {
        ways += process(arr, index + 1, rest - (zhang * arr[index]));
    }
    return ways;
}

代码解释

递归中，base case 为下标来到最后时，如果剩余的钱数为 0 ，说明前面的组合刚好能够凑出 aim 值，记为有效的一种情况。

选和不选 体现在 zhang 从 0 开始，直到该张数的面值超过了剩余钱数 rest 为止。继续调用递归且下标 index + 1 ，剩余钱数也相应减少。最终返回总的方法数即可。

写出该暴力版的递归之后修改出动态规划版的就很容易了。

动态规划版

public static int dp(int[] arr, int aim) {
    if (arr == null || arr.length == 0 || aim < 0) {
        return 0;
    }
    int N = arr.length;
    int[][] dp = new int[N + 1][aim + 1];
    dp[N][0] = 1;
    for (int index = N - 1; index >= 0; index--) {
        for (int rest = 0; rest <= aim; rest++) {
            int ways = 0;
            for (int zhang = 0; zhang * arr[index] <= rest; zhang++) {
                ways += dp[index + 1][rest - (zhang * arr[index])];
            }
            dp[index][rest] = ways;
        }
    }
    return dp[0][aim];
}

代码解释

可变的参数有两个：总的面值个数 N 和剩余的目标钱数 rest 。因此，需要设置一个二维的 dp 表数组，由于 N, rest 的取值范围是 0~N 、0~aim ，因此数组大小设置为 dp[N + 1][aim + 1] 。

递归代码 index == arr.length 可知，初始只有 dp[N][0] 的值为 1 。

因为递归中只依赖 index + 1 的值，所以 dp 表倒着填写。

根据递归调用 process(arr, 0, aim) 可知最终返回 dp[0][aim] 。

之前的文章写到这里就结束了，但 这次不一样 ！

观察递归的代码，发现竟然有 3 层 for 循环。为什么呢？

思考后发现， dp 表中的每个位置同样需要枚举后才能知道（之前的题目能够直接计算出来）。那有没有办法消掉这层枚举的 for 循环呢？答案是有的！

下面我们通过画 dp 表，探寻该动态规划应如何进一步优化。

假设此时剩余的总钱数 rest = 10，面值数 arr[i] = 3 。

一图胜千言~

通过枚举代码可知，arr[i][10] 的值，红色 = 黄色 + 3 个紫色。

黄色：不选面值为 3 的钱币时，rest 仍为 10，依赖下一格 i + 1。

紫色：分别选 1 张、2 张、3张…时，rest 对应每次减 3 ，且依赖下一格 i + 1 行。

稍加思考发现，蓝色的位置即 arr[i][10 - 3] 位置的值正是 3 个紫色的总和。那么，就可以将 红色 = 黄色 + 3 个紫色，改为 红色 = 黄色 + 蓝色，这样就不需要一直往前寻找了，减少一个 for 循环。

最终优化版动态规划

public static int dp(int[] arr, int aim) {
    if (arr == null || arr.length == 0 || aim < 0) {
        return 0;
    }
    int N = arr.length;
    int[][] dp = new int[N + 1][aim + 1];
    dp[N][0] = 1;
    for (int index = N - 1; index >= 0; index--) {
        for (int rest = 0; rest <= aim; rest++) {
            // 先令 红色 等于 黄色部分
            dp[index][rest] = dp[index + 1][rest];
            // 如果没越界，说明前面有蓝色部分，再加上蓝色部分
            if (rest - arr[index] >= 0) {
                dp[index][rest] += dp[index][rest - arr[index]];
            }
        }
    }
    return dp[0][aim];
}