以《换钱的方法数》来学动态规划及其优化

动态规划初步入门

近期在做程序员面试指南，里面有一道《换钱的方法数》问题，我觉得对理解动态规划和递归优化搜索很有帮助。

题目

给定数组arr，arr中所有的值都为正数且不重复。每一个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数CoinNum代表要找的钱数，求换钱的有多少种方法。

举例

arr=[5,10,25,1],CoinNum=0;

组成0元的方法有1种，就是所有货币都不用。所以返回1。

arr=[5,10,25,1],CoinNum=15;

组成15的方法有6种，分别为:

（1）3张5元

（2）1张10元+1张5元

（3）1张10元+5张1元

（4）10张1元+1张5元

（5）2张5元+5张1元

（6）15张1元

arr=[3,5]，CoinNum=2；

任何方法都无法组成2元，所以返回0。

普通递归代码（O（coinnum^n））

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
//leetcode518
int process1(vector<int>arr, int index, int aim)
{
	int res = 0;
	if (index == arr.size())
	{
		res = aim == 0 ? 1 : 0;
	}
	else
	{
		for (int i = 0; arr[index] * i <=aim; i++)
		{
			res += process1(arr, index + 1, aim - arr[index] * i);
		}
	}
	return res;
}
int coinsl(vector<int>arr, int aim)
{
	int res;
	if (arr.size() == 0 || aim < 0)
	{
		res = 0;
		return res;
	}
	else
	{
		return process1(arr, 0, aim);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	vector<int>arr = { 5, 10, 25, 1 };
	int aim = 15;
	int res = coinsl(arr, aim);
	cout << res;
	return 0;
}

说明

在我看来，解决这个问题如果用普通递归的话，代码写好三点就好了：

1. 代码递归的初识条件，在普通递归代码中，我们写的递归的初识条件就是

   int coinsl(vector<int>arr, int aim)
   {
   	int res;
   	if (arr.size() == 0 || aim < 0)
   	{
   		res = 0;
   		return res;
   	}
   	else
   	{
   		return process1(arr, 0, aim);
   	}
   }
   

   这样理解相当于在普通递归外套了一个“壳”

2.代码递归的结束条件，在普通递归代码中，我们写的递归的初识条件就是

if (index == arr.size())
	{
		res = aim == 0 ? 1 : 0;
	}

要给定递归结束的条件，比如说当前几个数已经组成完成钱数，这样就算1种方法

3、（最关键）循环条件

for (int i = 0; arr[index] * i <=aim; i++)
		{
			res += process1(arr, index + 1, aim - arr[index] * i);
		}

普通递归时间复杂度为O（coinnum^n）

记忆优化代码（O（N*coinnum^2））

#include"stdafx.h"
#include<iostream>
#include<cmath>
#include<string>
#include<vector>
using namespace std;
int process2(vector<int>arr, int index, int aim, vector<vector<int>>map)
{
	int res=0;
	int i, j;
	int mapValue = 0;
	if (index == arr.size())
	{
		if (aim == 0)
		{
			res = 1;
		}
		else
		{
			res = 0;
		}

	}
	else
	{

		for (i = 0; i*arr[index] <= aim; i++)
		{
			mapValue == map[index + 1][aim - i*arr[index]];
			if (mapValue == 0)
			{
				res += process2(arr, index + 1, aim - arr[index] * i, map);

			}
			else
			{
				if (mapValue == -1)
				{
					res += 0;
				}
				else
				{
					res += mapValue;
				}
			}

		}
	}
	if (res == 0)
	{
		map[index][aim] = -1;
	}
	else
	{
		map[index][aim] = res;
	}
	return res;
}
int coinsl(vector<int>arr, int aim)
{
	vector<vector<int>>map(arr.size()+1,vector<int>(aim+1));
	if (arr.size() == 0 || aim < 0)
	{
		return -2;
	}
	else
	{
		return process2(arr, 0, aim, map);
	}
}
int main()
{
	int a = 91;

	int aa = 92;
	vector<int>arr = { 5, 10, 25, 1};
	int aim = 15;
	int res = coinsl(arr, aim);
	cout << "换钱的方法数为：" << res << endl;
	return 0;
}

说明

记忆优化时间复杂为O（N*coinnum^2）

简述：暴力递归存在大量的重复计算，比如上面的例子，当已经使用0张5张+1张10元和使用2张5元和0张10元两种情况，剩下的钱组成15的可能，产生重复的计算，在暴力递归的过程中，这种计算会大量发生。记忆优化就是建立二维表map，每计算完一个递归过程，都将结果记录到map中，当下次进行也同样的递归过程之前，现在map中查询这个递归是否已经计算过。

动态规划代码（O(N*coinnum^2)）

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int coinsl(vector<int>arr, int coinnum)
{
	if (arr.size() == 0 || coinnum < 0)
	{
		return 0;
	}
	vector<vector<int>>dp(arr.size()+1 , vector<int>(coinnum + 1));
	int i, j,k;
	for (i = 0; i < arr.size() + 1; i++)
	{
		dp[i][0] = 1;
	}
	for (j = 0; j*arr[0]-coinnum<=0; j++)//这里要注意条件
	{
		dp[0][j*arr[0]] = 1;
	}
	int num = 0;
	for (i = 1; i < arr.size(); i++)
	{
		for (j = 1; j <=coinnum; j++)
		{
			num = 0;
			for (k = 0; j - k*arr[i] >= 0; k++)
			{
				num += dp[i - 1][j - k*arr[i]];
			}
			dp[i][j] = num;
		}
	}
	return dp[arr.size()-1][coinnum];
}
int main()
{
	int a = 91;
	int aa = 92;
	vector<int>arr = { 5, 10, 25, 1 ,2};
	int coinnum = 15;
	int res = coinsl(arr, coinnum);
	cout << "换钱的方法数为："<< res<<endl;
}

说明

动态规划算法，时间复杂度为O(N*coinnum^2)生成行数为arr.size()，列数为coinnum+1的二维向量，

dp[i][j]

表示在使用arr[0…i]货币的情况下，组成钱数j有多少种方法。

二维向量第一行和第一列的值好确定

剩下的值为以下的值的累加

完全不用arr[i]，只使用arr[0…i-1]货币时，方法数为dp(i-1,j)

用1张arr[i]货币，剩下的钱用arr[0…i-1]货币组成时，方法数为dp(i-1,j-arr[i])

用2张arr[i]货币，剩下的钱用arr[0…i-1]货币组成时，方法数为dp(i-1,j-2*arr[i])

…

用k张arr[i]货币时，剩下的钱用arr[0…i-1]货币组成时，方法数为dp(i-1,j-k*arr[i])

动态规划算法优化代码（O(N*coinnum）

for (i = 1; i < arr.size(); i++)
{
	for (j = 1; j <= coinnum; j++)
	{
		dp[i][j] = dp[i - 1][j];
		if (j - arr[i] >= 0)
		{
			dp[i][j]+= dp[i][j - arr[i]];//在这一步进行优化，第1种情况的方法数为dp[i][j-arr[i]]的值，从第2种情况到第k种情况的方法数其实就是累加dp[i][j-arr[i]]的值。
		}
		else
		{
			dp[i][j] += 0;
		}
	}
}

在使用动态规划优化算法时，其实就是省去了枚举的流程，与普通动态规划相比，不用k的变量了，时间复杂度为O(N*coinnum)。

动态规划算法进一步优化（时间O(N*coinnum，空间O（coinnum））

for (int j = 0; arr[0] * j <= coinnum; j++)
{
	dp[arr[0] * j] = 1;
}
for (int i = 1; i < arr.size(); i++)
{
	for (int j = 1; j < coinnum; j++)
	{
		if (j - arr[i] >= 0)
		{
			dp[j] += dp[j - arr[i]];
		}
		else
		{
			dp[j] += 0;
		}
	}
	return dp[coinnum];
}

在上一步优化的基础上，利用空间压缩原理，时间复杂度为O(N*coinnum)，空间复杂度为O（coinnum）

补充：空间压缩原理

通过一个数组滚动更新的方式节省了空间，这样很好。