引用：《背包问题——“01背包”最优方案总数分析及实现》及《背包问题——“完全背包”最优方案总数分析及实现》两篇文章

地址http://blog.csdn.net/wumuzi520/article/details/7014830

http://blog.csdn.net/wumuzi520/article/details/7014559

《背包问题——“01背包”及“完全背包”装满背包的方案总数分析及实现》》

地址http://blog.csdn.net/wumuzi520/article/details/7021210

   网上各大公司经常出题目：假设现在有1元、2元、5元的纸币很多张，现在需要20块钱，你能给多少种找钱方案，这就可以认为是完全背包问题，即背包容量为20，物品体积分别为1、2、5。

        还有公司出题目：给定一个数m，将m拆成不同的自然数的和的形式有多少种方案，这就是典型的01背包问题，背包容量为m，物品件数为k，这里面的k是隐含条件，可以求出来，因为m最多由1+2+…+k得到，由此可以根据m求得物品件数的上限。

动态规划——找零钱问题

[cpp] 
view plain
 copy找零钱递归实现

1. #include <iostream>  
2. using namespace std;  
3. const int M=1000;  
4. const int N = 3;  
5. int coint[N];  
6. int count[M+1];//count[i]表示凑合数量为i所需最少的钱币数量,则count[i]=min{count[i-coint[j]]+1},其中0<=j<=N-1  
7. int trace[M+1];//每个表示count[i]在取最小值时的选择，即上式中的j  
8. int dp_count(int m)  
9. {  
10.     int i = 0;  
11.     int j = 0;  
12.     for(i=0;i<M+1;i++)  
13.         count[i]=0xffff;  
14.     count[0] = 0;  
15.     for(i=0;i<=m;i++)  
16.     {  
17.         for(j=0;j<N;j++)  
18.             if(coint[j]<= i && count[i-coint[j]]+1 < count[i])  
19.             {  
20.                 count[i] = count[i-coint[j]]+1;  
21.                 trace[i] = coint[j];  
22.             }  
23.     }  
24.     return count[m];  
25. }  
26. void print(int m)  
27. {  
28.     if(m==0)  
29.         return;  
30.     else  
31.     {  
32.         cout << trace[m] << ”  “;  
33.         print(m-trace[m]);  
34.     }  
35. }  
36. int main()  
37. {  
38.     int i=0;  
39.     for(i=0;i<N;i++)  
40.         cin>>coint[i];  
41.     int m;  
42.     cin >> m;  
43.     cout<<dp_count(m)<<endl;  
44.     print(m);  
45. }  

找零钱递归实现

题目：现有1元、2元、5元、10元、20元面值不等的钞票，问需要20元钱有多少种找钱方案，打印所有的结果！

分析：此题如果没要求打印结果，只要求打印出一共有多少种方案，那么可以直接用动态规划，参考背包问题——“01背包”及“完全背包”装满背包的方案总数分析及实现

如果要求打印所有结果，那递归是再好不过的了。

[html] 
view plain
 copy

1. #include <iostream>  
2. #include <string.h>  
3. using namespace std;  
4.   
5. //20块钱找零，零钱由1、2、5、10四种币值  
6. #define MAX_VALUE   20  
7.   
8. int array[] = {1,2,5,10,MAX_VALUE};  
9. int next[MAX_VALUE] = {0};  
10.   
11. void SegNum(int nSum, int* pData, int nDepth)  
12. {  
13.     if(nSum < 0)  
14.         return;  
15.   
16.     if(nSum == 0)  
17.     {  
18.         for(int j = 0; j < nDepth; j++)  
19.             cout << pData[j] << ” “;  
20.         cout << endl;  
21.   
22.         return;  
23.     }  
24.   
25.     int i = (nDepth == 0 ? next[0] : pData[nDepth-1]);  
26.     for(; i <= nSum;)  
27.     {  
28.         pData[nDepth++] = i;  
29.         SegNum(nSum-i,pData,nDepth);  
30.         nDepth–;  
31.   
32.         i = next[i];  
33.     }  
34. }  
35.   
36. void ShowResult(int array[],int nLen)  
37. {  
38.     next[0] = array[0];  
39.     int i = 0;  
40.     for(; i < nLen-1; i++)  
41.         next[array[i]] = array[i+1];  
42.     next[array[i]] = array[i]+1;  
43.   
44.     int* pData = new int [MAX_VALUE];  
45.     SegNum(MAX_VALUE,pData,0);  
46.     delete [] pData;  
47. }  

测试代码如下

[cpp] 
view plain
 copy

1. int main()  
2. {  
3.     //找零钱测试  
4.     ShowResult(array,sizeof(array)/sizeof(int));  
5.   
6.     system(“pause”);  
7.     return 0;  
8. }