作者：Grey
原文地址：
问题描述
现有 n1 + n2 种面值的硬币，其中前 n1 种为普通币，可以取任意枚，后 n2 种为纪念币， 每种最多只能取一枚（可能有重复值），每种硬币有一个面值，问能用多少种方法拼出 m 的面值?
题目链接见：牛客-拼凑硬币
主要思路
如果都用普通币，组合出 m 有多少种方法？假设得到 x 种方法。
如果都用纪念币，组合出 m 有多少种方法？假设得到 y 种方法。
如果是普通币 + 纪念币，组合出 m 有多少种方法？ 假设得到 z 种方法。
则 x + y + z 就是结果。
所以需要定义两个递归函数。
第一个递归函数：用纪念币，组成不同钱数的组合数量有多少
long[][] one(int[] arr, int money)
递归含义表示：用纪念币，返回组成不同钱数的组合数量有多少。由于纪念币每种最多只能选一个，所以这是一个经典的背包问题。
注：这个递归返回的是一个二维数组 dp，dp[i][j]表示 0 号到 i 号纪念币任意选择的情况下，组合出 m 有多少种方法。
递归含义确定后，二维数组 dp 的第 0 列的值已经可以很快确定，因为 dp[i][0] 表示 0 号到 i 号纪念币任意选择的情况下，组成 0 面值有多少方法。
显然只有一种方法，就是什么都不选，即
for (int i = 0; i < arr.length; i++) {
dp[i][0] = 1;
}
dp[0][arr[0]] 的值也可以确定，因为 dp[0][arr[0]] 表示：0 号面值的纪念币，如何组成arr[0] 的面值，显然只有一种方法，就是选 0 号的面值，但是需要满足一个条件，即 arr[0] <= money，即
if (arr[0] <= money) {
dp[0][arr[0]] = 1;
}
接下来就是普遍情况，对于任意 dp[i][j] 来说，首先可以有一种决策，不要 i 位置的纪念币，即
dp[i][j] = dp[i-1][j]
第二种决策，就是使用 i 位置的一枚纪念币，此时，要满足前提条件，即 arr[i] 位置的面值不能超过剩余面值
即：
dp[i][j] += j - arr[i] >= 0 ? dp[i - 1][j - arr[i]] : 0;
递归函数的完整代码如下
public static long[][] one(int[] arr, int money) {
if (arr == null || arr.length == 0) {
return null;
}
long[][] dp = new long[arr.length][money + 1];
for (int i = 0; i < arr.length; i++) {
dp[i][0] = 1;
}
if (arr[0] <= money) {
dp[0][arr[0]] = 1;
}
for (int i = 1; i < arr.length; i++) {
for (int j = 1; j <= money; j++) {
dp[i][j] = dp[i - 1][j];
dp[i][j] += j - arr[i] >= 0 ? dp[i - 1][j - arr[i]] : 0;
dp[i][j] %= MOD;
}
}
return dp;
}
第二个递归函数：用普通币，组成不同钱数的组合数量有多少
long[][] many(int[] arr, int money)
递归含义表示：用普通币，组成不同钱数的组合数量有多少。也是返回一个二维数组 dp，dp[i][j]表示 0 号到 i 号普通币任意选择的情况下，组合出 m 有多少种方法。
根据递归含义，二维数组 dp 的第 0 列的值全为 1， 组成 0 面值的组合只有一种情况，就是用 0 枚普通币。即
for (int i = 0; i < arr.length; i++) {
dp[i][0] = 1;
}
第 0 行也比较好确认，就是枚举 arr[0] 最多可以使用多少枚，即
for (int j = 1; arr[0] * j <= money; j++) {
dp[0][arr[0] * j] = 1;
}
接下来是普遍位置，dp[i][j] 有两个决策，第一个决策，不使用 i 位置的普通币，即
dp[i][j] = dp[i-1][j]
第二个决策，使用 i 位置的普通币，此时，要满足前提条件，即 arr[i] 位置的面值不能超过剩余面值
即：
dp[i][j] += j - arr[i] >= 0 ? dp[i][j - arr[i]] : 0;
所以，递归函数的完整代码如下
public static long[][] many(int[] arr, int money) {
if (arr == null || arr.length == 0) {
return null;
}
long[][] dp = new long[arr.length][money + 1];
for (int i = 0; i < arr.length; i++) {
dp[i][0] = 1;
}
for (int j = 1; arr[0] * j <= money; j++) {
dp[0][arr[0] * j] = 1;
}
for (int i = 1; i < arr.length; i++) {
for (int j = 1; j <= money; j++) {
dp[i][j] = dp[i - 1][j];
dp[i][j] += j - arr[i] >= 0 ? dp[i][j - arr[i]] : 0;
dp[i][j] %= MOD;
}
}
return dp;
}
整合函数，普通币和纪念币一起使用
有了上述两个 dp ，就可以很方便计算两种硬币一起使用过程的组合数量，核心思路就是这句
dpMany[dpMany.length - 1][i] * dpOne[dpOne.length - 1][money - i];
即：只用 普通币完成 i 面值的组合数量是 M，用纪念币完成 money - i 面值的组合数量是 N，则 M * N 就是两者一起用组合成 money 面值的组合数量。
这个整合函数的完整代码如下
public static long moneyWays(int[] many, int[] one, int money) {
if (money < 0) {
return 0;
}
if ((many == null || many.length == 0) && (one == null || one.length == 0)) {
return money == 0 ? 1 : 0;
}
long[][] dpMany = many(many, money);
long[][] dpOne = one(one, money);
if (dpMany == null) {
return dpOne[dpOne.length - 1][money];
}
if (dpOne == null) {
return dpMany[dpMany.length - 1][money];
}
long res = 0;
for (int i = 0; i <= money; i++) {
res += dpMany[dpMany.length - 1][i] * dpOne[dpOne.length - 1][money - i];
res %= MOD;
}
return res;
}
完整代码
import java.util.Scanner;
public class Main {
static int MOD = (int) 1e9 + 7;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n1 = in.nextInt();
int n2 = in.nextInt();
int target = in.nextInt();
int[] many = new int[n1];
int[] one = new int[n2];
for (int i = 0; i < n1; i++) {
many[i] = Integer.parseInt(in.next());
}
for (int i = 0; i < n2; i++) {
one[i] = Integer.parseInt(in.next());
}
System.out.println(moneyWays(many, one, target));
in.close();
}
public static long moneyWays(int[] many, int[] one, int money) {
if (money < 0) {
return 0;
}
if ((many == null || many.length == 0) && (one == null || one.length == 0)) {
return money == 0 ? 1 : 0;
}
long[][] dpMany = many(many, money);
long[][] dpOne = one(one, money);
if (dpMany == null) {
return dpOne[dpOne.length - 1][money];
}
if (dpOne == null) {
return dpMany[dpMany.length - 1][money];
}
long res = 0;
for (int i = 0; i <= money; i++) {
res += dpMany[dpMany.length - 1][i] * dpOne[dpOne.length - 1][money - i];
res %= MOD;
}
return res;
}
public static long[][] many(int[] arr, int money) {
if (arr == null || arr.length == 0) {
return null;
}
long[][] dp = new long[arr.length][money + 1];
for (int i = 0; i < arr.length; i++) {
dp[i][0] = 1;
}
for (int j = 1; arr[0] * j <= money; j++) {
dp[0][arr[0] * j] = 1;
}
for (int i = 1; i < arr.length; i++) {
for (int j = 1; j <= money; j++) {
dp[i][j] = dp[i - 1][j];
dp[i][j] += j - arr[i] >= 0 ? dp[i][j - arr[i]] : 0;
dp[i][j] %= MOD;
}
}
return dp;
}
public static long[][] one(int[] arr, int money) {
if (arr == null || arr.length == 0) {
return null;
}
long[][] dp = new long[arr.length][money + 1];
for (int i = 0; i < arr.length; i++) {
dp[i][0] = 1;
}
if (arr[0] <= money) {
dp[0][arr[0]] = 1;
}
for (int i = 1; i < arr.length; i++) {
for (int j = 1; j <= money; j++) {
dp[i][j] = dp[i - 1][j];
dp[i][j] += j - arr[i] >= 0 ? dp[i - 1][j - arr[i]] : 0;
dp[i][j] %= MOD;
}
}
return dp;
}
}