其他分享
首页 > 其他分享> > 深入浅出零钱兑换问题——背包问题的套壳

深入浅出零钱兑换问题——背包问题的套壳

作者：互联网

深入浅出零钱兑换问题——背包问题的套壳

前言

在本篇文章当中主要通过介绍两个算法题，从最基本的问题开始深入浅出零钱兑换问题，帮助大家从动态规划的本源深入理解问题当中的原理，并且学会自己分析问题，分析数据之间的依赖关系，通过分析这种关系自己推导算法的优化过程，再也不怕类似于背包问题的算法题了。

零钱兑换

题目

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例

示例1

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1

示例2

输入：coins = [2], amount = 3
输出：-1

状态表示和状态转移方程

在求解动态规划问题的时候通常的步骤有以下几个：

状态表示数组

在背包问题当中通常都是用一个二维数组表示数据的状态，在这个问题当中我们使用一个二维数组dp表示我们需要的状态：

dp[i][j]表示使用coins前i种面额的硬币表示金额等于j时使用的最少的金币，那么我们最终答案就是dp[N][amount]，他表示使用coins数组当中所有面额的硬币表示amount需要的最少的硬币个数。

寻找动态转移方程

在确定了状态表示的数组之后，现在我们就需要分析出动态转移方程了，在这个问题当中对于每一种面额的硬币我们都有两种选择：选和不选，但是在这个问题当中题目已经说明了对于每一种货币都可以认为是无限的，如果我们不选择，那这种情况比较简单，但是如果选择了这种情况就比较复杂了：

很显然我们需要从上面两种情况当中选择需要的硬币最少的一种方法，因此综合上面的结果又如下的动态转移方程：

\[dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1) \]

其实上面这个问题的分析过程跟完全背包可以说是一模一样，如果你对完全背包感兴趣，你可以阅读这篇文章完全背包。

初始化状态数组

上面的问题分析过程当中，我们已经分析出来了动态转移方程，这个过程和完全背包非常相似，但是这个问题比完全背包还稍微复杂一点，因为不一定能够寻找到这样一种组合凑成的总金额等于题目当中规定的数目。我们用-1表示找不到这样一种组合能够表示。

for (int i = 0; i * coins[0] <= amount; i++) {
    dp[0][i * coins[0]] = i;
}

dp数组的第一行表示只使用第一种面额的硬币，因此只有第一种硬币面额的整数倍总金额才能使用第一种硬币进行表示，而且对应的硬币个数等于\(\frac{amout}{coins[0]}\)。

再看状态转移数组：

\[dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1) \]

代码

class Solution {
  public int coinChange(int[] coins, int amount) {
    int[][] dp = new int[coins.length][amount + 1];
    Arrays.fill(dp[0], -1);
    for (int i = 0; i * coins[0] <= amount; i++) {
      dp[0][i * coins[0]] = i;
    }
    for (int i = 1; i < coins.length; i++) {
      for (int j = 0; j <= amount; j++) {
        // 如果要使用对应的硬币 
        // 总金额数目肯定要大于硬币的面额
        if (j >= coins[i]) {
          if (dp[i][j - coins[i]] == -1)
            dp[i][j] = dp[i - 1][j];
          else if (dp[i - 1][j] == -1)
            dp[i][j] = dp[i][j - coins[i]] + 1;
          else
            dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - coins[i]] + 1);
        } else {
          // 否则只能使用前 i-1 种硬币
          dp[i][j] = dp[i - 1][j];
        }
      }
    }
    return dp[coins.length - 1][amount];
  }
}

上面的代码体现的就是完全背包 的思想，在题目当中硬币可以使用无限次，如果只能使用一次的话，问题就转换成01背包了，那么动态转移方程就为：

\[dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - coins[i]] + 1) \]

单行数组优化

根据动态转移方程\(dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1)\)，我们可以得到dp数组当中数据之间的依赖关系，他们的关系如上图所示，dp[i][j]依赖的数据为它上一行同列的位置，和第i行前面的某些数据，事实上我们可以使用单行数组去进行实现，我们使用的循环还是一样的，但是使用的数组有所变化，从之前的二维数组变成一维数组。当我们遍历到单行数组第j个数据的时候，第j个数据还是上一行的状态，但是单行数组的下标从0到j-1的位置数据的状态已经从上一行更新了，这些数据的状态相当于二维数组的dp[i]这一行的状态，而这正好可以满足动态转移方程的需求，因为在动态转移方程当中，dp[i-1][j]依赖的数据全部符合条件，单行数组当中的下标为j数据等于dp[i][j]，单行数组下标为x的数据等于dp[i][x]，其中\(0 \le x \le j\)，这里你可以结合代码、文字和图片进行理解，理解效果会更加好一点。

class Solution {
  public int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    Arrays.fill(dp, -1);
    dp[0] = 0;
    for (int i = 0; i < coins.length; i++) {
      for (int j = coins[i]; j <= amount; j++)  {
        if (dp[j - coins[i]] != -1) {
          if (dp[j] == -1) {
            dp[j] = dp[j - coins[i]] + 1;
          }else
            dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
        }
      }
    }
    return dp[amount];
  }
}

另一种角度思考问题

在上面的文章当中，我们是使用-1去表示不能够找到一个组合满足总金额数目。我们可以先将数组当中所有的数据全部初始化成amount + 1，这个是硬币的上界，如果我们全部使用一块的硬币进行兑换，结果是amount，因此最大的值不会超过amount + 1，因为在动态转移方程当中求的是最小值，因此在进行状态转移的时候不会选择这个值，因此下面的代码也是正确的！！！

class Solution {
  public int coinChange(int[] coins, int amount) {
    int max = amount + 1;
    int[] dp = new int[amount + 1];
    for (int j = 0; j < dp.length; j++) {
      dp[j] = max;
    }
    dp[0] = 0;
    for (int i = 0; i < coins.length; i++) {
      for (int j = coins[i]; j <= amount; j++) {
        if (dp[j - coins[i]] != max) {
          dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
        }
      }
    }
    return dp[amount] == max ? -1 : dp[amount];
  }
}

零钱兑换 II

题目

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

示例

示例1

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例2

输入：amount = 3, coins = [2]
输出：0
解释：只用面额 2 的硬币不能凑成总金额 3 。

状态表示和状态转移方程

状态表示数组

在这个问题当中我们也是使用一个二维数组表示我们的状态dp[i][j]。这个表示使用前i个硬币，总金额为j的情况下，能够找到多少种组合方式，是硬币的和等于总金额数。

在这道题目当中我们也可以使用无数次硬币，因此这也是一个完全背包问题。

寻找动态转移方程

对于每一种硬币同样的有两种情况选择和不选择，每一种情况都有不同的组合，因此最终的组合数目就是将这两个结果相加：

因此最终的组合数的个数就是上面两种方式的不同组合个数相加，因此我们的动态转移方程为：

\[dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]]; \]

初始化状态数组

在初始化dp数组的第一行的时候，只有是第一个硬币的整数倍的总金额才能进行匹配，如果不能匹配，那么不同的组合的数目就等于0，能够进行匹配的组合数也只有一个，那就是使用的硬币全是第一种硬币。在这里需要注意的是当总金额等于0的时候，也是有一种组合方式的，那就是没有一个硬币，这也是一种组合方式，就相当于集合的空基，因此初始化代码如下：

for (int i = 0; i * coins[0] <= amount; i++) {
  dp[0][i * coins[0]] = 1;

代码

class Solution {
  public int change(int amount, int[] coins) {
    int[][] dp = new int[coins.length][amount + 1];
    // dp[i][j] 的含义：前 i 个钱 容量 j 有多少种方法
    for (int i = 0; i * coins[0] <= amount; i++) {
      dp[0][i * coins[0]] = 1;
    }
    for (int i = 1; i < coins.length; i++) {
      for (int j = 0; j <= amount; j++) {
        if (j >= coins[i]) {
          dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]];
        } else
          dp[i][j] = dp[i - 1][j];
      }
    }
    return dp[coins.length - 1][amount];
  }
}

其实这道题也有对应的01背包问题，在这道题目当中是完全背包问题的变种，如果所有的硬币只能够使用一次的话，那么动态转移方程如下：

\[dp[i][j] = dp[i - 1][j] + dp[i - 1][j - coins[i]]; \]

单行数组优化

class Solution {
  public int change(int amount, int[] coins) {
    int[] dp = new int[amount + 1];
    // dp[i][j] 的含义：前 i 个钱 容量 j 有多少种方法
    dp[0] = 1;
    for (int i = 0; i < coins.length; i++) {
      for (int j = coins[i]; j <= amount; j++)
        dp[j] += dp[j - coins[i]];
    }
    return dp[amount];
  }
}

这个优化的原理和第一题也是一样的，通过分析动态转移方程，看单行数组是否能够满足动态转移方程的要求，如果能够满足的话，那就能够进行单行数组优化，反之不能进行优化，而在这个问题当中，数据依赖关系和第一题是一样的，dp[i][j]依赖的数据是dp[i - 1][j]和dp数组第i行前j - 1个数据，根据第一题的分析，我们是可以使用单行数组进行优化的！！！

总结

在本篇文章当中主要给大家介绍了两道零钱兑换的问题，在本文当中的这两道题目都是属于完全背包的变种，如果要彻底弄懂这个问题的话就需要好好分析动态转移方程和数据之间的依赖关系，通过分析数据之间的依赖关系，我们自己也可以从零推导优化过程。在这两道问题当中硬币都可以使用无数次，如果将能够使用的硬币只能够使用一次的话，那么这个问题就变成01背包的变种问题了。

更多精彩内容合集可访问项目：https://github.com/Chang-LeHung/CSCore

关注公众号：一无是处的研究僧，了解更多计算机（Java、Python、计算机系统基础、算法与数据结构）知识。

标签：背包,硬币,int,深入浅出,零钱,amount,数组,coins,dp
来源： https://www.cnblogs.com/Chang-LeHung/p/16534083.html