动态规划之硬币划分

硬币划分

有1分，2分，5分，10分四种硬币，每种硬币数量无限，给定n分钱(n <= 100000)，有多少中组合可以组成n分钱？

问题分析

给定一个数值sum，我们的硬币类型{$V_1$,$V_2$,…$V_m$},
sum = $x_1$* $V_1$ + $x_2$ * $V_2$ + … + $x_m$ * $V_m$;
显然，求组合数，就是求{$x_1$, $x_2$, … , $x_m$}的种数。

令dp[i][sum]表示i种硬币构成sum的组合数
我们再来看，
当$x_m$=0时，前m-1种硬币构成sum的组合数是dp[i-1][sum]
当$x_m$=1时，前m-1种硬币构成sum-Vm的组合数是dp[i-1][sum - Vm]
…
当$x_m$=sum/$V_m$时，前m-1种硬币构成sum-xm*Vm的组合数是dp[i-1][sum - xm * Vm]

显然，$x_m$从0取到$sum/V_m$的所有情况数就是sum由硬币类型{V1,V2, …Vm}构成的组合数。故，写成公式即：

$$d_p[i][sum]=d_p[i-1][sum]+d_p[i-1][sum-V_m]+...+d_p[i-1][sum-x_m\ast Vm]$$

即
$$d_p[i][sum]=\sum _{k=0}^{k=sum/V_m}{d}_p[i-1][sum-k\ast V_m]$$

我们对以上公式进行递推, 为了更好地理解循环，我们重写
$$sum=x_0\ast coins[0]+x_1\ast coins[1]+...+x_{i-2}\ast coins[i-2]+x_{i-1}\ast coins[i-1]$$

其中coins = {1，2，5，10}, i <= coins.length;

为了方便理解，我们把$x_{i-1}$用 $k$ 表示，$x_{i-2}$用 $ϵ$ 表示

接着继续递推前面的公式
$$d_p[i-1][sum-k\ast coins[i-1]]=\sum _{ϵ=0}^{ϵ=sum-k\ast conis[i-1]/coins[i-2]}{d}_p[i-2][sum-kconis[i-1]-ϵ\ast coins[i-2]]$$
由此递推可得，
…
…
…
$$d_p[2][S]=\sum _{t=0}^{t=S/coins[1]}{d}_p[1][S-t\ast coins[1]]$$
其中，$S$ 表示的是
$$S=sum-k\ast coins[i-1]-ϵ\ast coins[i-2]-...-x_2\ast coins[2]$$

$$d_p[1][G]=\sum _{t=0}^{t=G/coins[0]}{d}_p[0][G-t\ast coins[0]]$$
其中，$G$ 表示的是
$$G=sum-k\ast coins[i-1]-ϵ\ast coins[i-2]-...-x_1\ast coins[1]$$

显然，G是由于$x_0$*coins[0] 变化到 $sum$
对于$d_p[1][G]$, 内层循环 k 从$x_0$ 变化到$sum/coins[i-1]$,外层循环G从$x_0\ast coins[0]$ 变化到 $sum$; 由于 {$x_0$, $x_1$,…,$x_{i-1}$}都是未知的，且其种数，是所有，故，都从1开始逐步递增。（个人理解，如有错误，望指出）

该部分代码片段如下：

    for (int i = 1; i <= coinKinds; ++i)
    {
        for (int j = 1; j <= sum; ++j)
        {
            dp[i][j] = 0;
            for (int k = 0; k <= j / coins[i-1]; ++k)
            {
                dp[i][j] += dp[i-1][j - k * coins[i-1]];
            }
        }
    }

附完整代码

/* 
 * Filename :coins.cpp
 * Description: solve coin combinations using dynamic programing
 * Complier: g++
 * Author: python27
 */
#include <iostream>
#include <string>
#include <cmath>
#include <vector>

using namespace std;

/****************************************************************
 * coin Combinations: using dynamic programming
 *
 * Basic idea:
 * dp[i][j] = sum(dp[i-1][j-k*coins[i-1]]) for k = 1,2,..., j/coins[i-1]
 * dp[0][j] = 1 for j = 0, 1, 2, ..., sum
 * 
 * Input:
 * coins[] - array store all values of the coins
 * coinKinds - how many kinds of coins there are
 * sum - the number you want to construct using coins
 *
 * Output:
 * the number of combinations using coins construct sum
 *
 * Usage:
 * c[3] = {1, 2, 5};
 * int result = coinCombinations(c, 3, 10);
 *
 ****************************************************************/
int coinCombinations(int coins[], int coinKinds, int sum)
{
    // 2-D array using vector: is equal to: dp[coinKinds+1][sum+1] = {0};
    vector<vector<int> > dp(coinKinds + 1);
    for (int i = 0; i <= coinKinds; ++i)
    {
        dp[i].resize(sum + 1);
    }
    for (int i = 0; i <= coinKinds; ++i)
    {
        for (int j = 0; j <= sum; ++j)
        {
            dp[i][j] = 0;
        }
    }

    //init: dp[i][0] = 1; i = 0, 1, 2 ..., coinKinds
    //Notice: dp[0][0] must be 1, althongh it make no sense that
    //using 0 kinds of coins construct 0 has one way. but it the foundation
    //of iteration. without it everything based on it goes wrong
    for (int i = 0; i <= coinKinds; ++i)
    {
        dp[i][0] = 1;
    }

    // iteration: dp[i][j] = sum(dp[i-1][j - k*coins[i-1]])
    // k = 0, 1, 2, ... , j / coins[i-1]
    for (int i = 1; i <= coinKinds; ++i)
    {
        for (int j = 1; j <= sum; ++j)
        {
            dp[i][j] = 0;
            for (int k = 0; k <= j / coins[i-1]; ++k)
            {
                dp[i][j] += dp[i-1][j - k * coins[i-1]];
            }
        }
    }

    return dp[coinKinds][sum];
}

int main()
{
    int coins[8] = {1, 2, 5, 10, 20, 50, 100, 200};
    int sum = 200;
    int result = coinCombinations(coins, 8, 200);
    cout << "using 8 kinds of coins construct 200, combinations are: " << endl;
    cout << result << endl;
    return 0;
}

参考大佬的链接附上：
https://www.cnblogs.com/python27/archive/2013/09/05/3303721.html

---

##-----------------------------------------------这是分割线，上面的解决方法分析那块很好理解，写出代码就难理解了---------------------------------我是分割线--------------------------
又看到一个大佬写的代码，很好理解------在这里贴出来，mark一下---------------------------------
-------我是无情的分割线--------------------------------------------------

分析

给定一个数值n，n无非是由{1，2，5，10} 这几种硬币组成，最极端的情况下，n是由10构成，

for(int a1 =0; a1 <= n/10; a1++){
...
}

在a1所有的可能取值下，b1 最极端的情况下是由5构成的，

	for (int a1 = 0; a1 <= n / 10; a1++) {
		int b1 = n - a1 * 10;
		for (int a2 = 0; a2 <= b1 / 5; a2++) {
		...
	}

附完整代码如下

#include<iostream>
using namespace std;
const long long mod = 1000000007;
int main()
{
	long long count = 0;
	int n;
	cin >> n;
	for (int a1 = 0; a1 <= n / 10; a1++) {
		int b1 = n - a1 * 10;
		for (int a2 = 0; a2 <= b1 / 5; a2++) {
			int b2 = b1 - a2 * 5;
			for (int a3 = 0; a3 <= b2 / 2; a3++)
				count++;
		}
	}
	int result = count % mod;
	cout << result;
	system("pause");
}