零钱组合的几种解法

存在这样一个数组， int arr[100]={5,10,25,1}; 里面是各种零钱的金额，我们还假设每一种零钱都有无数种，请问这些金钱组成一个特定面额数值的组合数。

比如 要组成1元，则情况为

     5   10   25   1

    0     0      0    10

    0     1     0      0

    1     0     0      5

     2    0      0     0

一共四种可能，我们可以看到，如果只有五元的时候，其最大数目为10/5=2，如果只有一张10元，最大数目为10/10=1，如果只有一张1元，最大数目为10/1=10,而我们这里有四种面额的零钱，那该怎么办？

使用深度搜索。

首先写出来这个问题的简单递归形式。

这个递归形式可以有两个版本

第一个是每次组合的时候，如果加到我们要的数额，就把全局变量自增，第二种原理是每次递归到边界返回，然后检查aim是否为0，如果是0，则代表本元素，或者以前的元素，已经累加到我们要求的值了，返回1，如果非0，则代表还“剩了点”，这样的话证明这个组合不符合，要返回重新递归，返回0.

版本1

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
int arr[100]={5,10,25,1};
int numcount=0;
void fun(int arr[],int index,int aim)
{
   int ret=0;

     if(aim==0)
	 {
		 numcount++;
		 return;
	 }
   if(index==4)
   {
     return;
   }
  
   for(int i=0;i*arr[index]<=aim;i++)
   {
	   fun(arr,index+1,aim-i*arr[index]);
   }
 
  
  
}
int main()
{

	fun(arr,0,15);
	cout<<numcount<<endl;
  return 0;
}

版本2

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
int arr[100]={5,10,25,1};

int fun(int arr[],int index,int aim)
{
	 int ret=0;
   if(index==4)
   {
     if(aim==0)
		 return 1;
	 else
		 return 0;
   }
  
   for(int i=0;i*arr[index]<=aim;i++)
   {
	  ret+=fun(arr,index+1,aim-i*arr[index]);
   }
 return ret;
  
  
}
int main()
{

	cout<<fun(arr,0,15)<<endl;
	
  return 0;
}

而这个问题本身是个递归问题，而分析其解空间树，可以发现他重复计算了很多值，比如，总金额为1000，0个5,1个10，求剩下的{25,1}组成,990的可能数，和2个5,0个10，{25,1}所能凑成990的可能数目就重复，所以我们还可以申请一个二维数组，来记录其特定的index  aim的组合数，防止了无用递归。

代码如下

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
int arr[100]={5,10,25,1};

int record[3][1000];
int fun(int arr[],int index,int aim)
{
	 int ret=0;
   if(record[index][aim]!=0)
   {
     return record[index][aim];
   }
   if(index==4)
   {
	
     if(aim==0)
		 return 1;
	 else
		 return 0;
   }
  
   for(int i=0;i*arr[index]<=aim;i++)
   {
	  ret+=fun(arr,index+1,aim-i*arr[index]);
   }
   record[index][aim]=ret;
 return ret;
  
  
}
int main()
{
	memset(record,0,sizeof(record));
	cout<<fun(arr,0,15)<<endl;

  return 0;
}

这个是递归转动态规划的一个过渡阶段，其中的record[index][aim]正是动态规划二维矩阵的横竖坐标，所以如果基础不好，做题时候不能上来就动态规划，应该先写递归形式，再进行记忆存储，进行优化，再然后根据这个优化写出动态规划，以推导形式导出结果。