找零

问题：

假设有m种面值不同的硬币，个个面值存于数组S ={S1，S2，… Sm}中，现在用这些硬币来找钱，各种硬币的使用个数不限。 求对于给定的钱数N，我们最多有几种不同的找钱方式。硬币的顺序并不重要。

例如，对于N = 4，S = {1,2,3}，有四种方案：{1,1,1,1}，{1,1,2}，{2,2}，{1， 3}。所以输出应该是4。对于N = 10，S = {2,5, 3,6}，有五种解决办法：{2,2,2,2,2}，{2,2,3,3}，{2,2,6 }，{2,3,5}和{5,5}。所以输出应该是5。

1）最优子结构
要算总数的解决方案，我们可以把所有的一整套解决方案在两组 (其实这个方法在组合数学中经常用到，要么包含某个元素要么不包含，用于递推公式等等，)。
1）解决方案不包含 第m种硬币（或Sm）。
2）解决方案包含至少一个 第m种硬币。
让数（S [] , M, N）是该函数来计算解的数目，则它可以表示为计数的总和（S [], M-1, N）和计数（S []，M，N-Sm）。

因此，这个问题具有最优子结构性质的问题。

2) 重叠子问题

下面是一个简单的递归实现硬币找零问题。遵循上面提到的递归结构。

01	#include<stdio.h>

02	int count( int S[], int m, int n )

03

{

04	// 如果n为0，就找到了一个方案

05	if (n == 0)

06

return 1;

07	if (n < 0)

08

return 0;

09	// 没有硬币可用了，也返回0

10	if (m <=0 )

11

return 0;

12	// 按照上面的递归函数

13	return count( S, m - 1, n ) + count( S, m, n-S[m-1] );

14

}

15

16

// 测试

17	int main()

18

{

19

int i, j;

20	int arr[] = {1, 2, 3};

21	int m = sizeof(arr)/sizeof(arr[0]);

22	printf("%d ", count(arr, m, 4));

23	getchar();

24

return 0;

25

}

应当指出的是，上述函数反复计算相同的子问题。见下面的递归树为S = {1，2，3}，且n = 5。
的函数C（{1}，3）被调用两次。如果我们绘制完整的树，那么我们可以看到，有许多子问题被多次调用。

01	C() --> count()

02	C({1,2,3}, 5)

03	/                \

04	/                   \

05	C({1,2,3}, 2)                 C({1,2}, 5)

06	/     \                        /         \

07	/        \                     /           \

08	C({1,2,3}, -1)  C({1,2}, 2)        C({1,2}, 3)    C({1}, 5)

09	/     \            /    \            /     \

10	/        \          /      \          /       \

11	C({1,2},0)  C({1},2)   C({1,2},1) C({1},3)    C({1}, 4)  C({}, 5)

12	/ \      / \       / \        /     \

13	/   \    /   \     /   \      /       \

14	.      .  .     .   .     .   C({1}, 3) C({}, 4)

15

/  \

16

/    \

17

.      .

所以，硬币找零问题具有符合动态规划的两个重要属性。像其他典型的动态规划（DP）的问题，可通过自下而上的方式打表，存储相同的子问题。当然上面的递归程序也可以改写成记忆化存储的方式来提高效率。

下面是动态规划的程序：

01	#include<stdio.h>

02

03	int count( int S[], int m, int n )

04

{

05	int i, j, x, y;

06

07	// 通过自下而上的方式打表我们需要n+1行

08	// 最基本的情况是n=0

09	int table[n+1][m];

10

11	// 初始化n=0的情况 (参考上面的递归程序)

12	for (i=0; i<m; i++)

13	table[0][i] = 1;

14

15	for (i = 1; i < n+1; i++)

16

{

17	for (j = 0; j < m; j++)

18

{

19	// 包括 S[j] 的方案数

20	x = (i-S[j] >= 0)? table[i - S[j]][j]: 0;

21

22	// 不包括 S[j] 的方案数

23	y = (j >= 1)? table[i][j-1]: 0;

24

25	table[i][j] = x + y;

26

}

27

}

28	return table[n][m-1];

29

}

30

31

// 测试

32	int main()

33

{

34	int arr[] = {1, 2, 3};

35	int m = sizeof(arr)/sizeof(arr[0]);

36	int n = 4;

37	printf(" %d ", count(arr, m, n));

38

return 0;

39

}

时间复杂度：O(mn)

以下为上面程序的优化版本。这里所需要的辅助空间为O(n)。因为我们在打表时，本行只和上一行有关，类似01背包问题。

01	int count( int S[], int m, int n )

02

{

03	int table[n+1];

04	memset(table, 0, sizeof(table));

05

//初始化基本情况

06	table[0] = 1;

07

08	for(int i=0; i<m; i++)

09	for(int j=S[i]; j<=n; j++)

10	table[j] += table[j-S[i]];

11

12	return table[n];

13

}

参考：http://www.geeksforgeeks.org/dynamic-programming-set-7-coin-change/

http://www.algorithmist.com/index.php/Coin_Change