1.简介：

在leetcode上刷题的时候，遇到了一道找零钱的动态规划题，后台测试用例很变态，必须把算法优化的很好才能通过。也借此机会好好的研究了一下动态规划。在下小白一个，大神轻喷。

2.题目如下：

image.png

分析：我们可以从最简单的暴力搜索开始，先优化成记忆搜索方法，再到动态规划，最后再对动态规划进行空间优化。

1)最简单的思路就是用暴力搜索的方法，枚举每一种情况，累加求和，但存在大量重复计算。时间复杂度 > O((amount * coins.length)²)

2)进一步我们可以优化成记忆搜索方法，将每一个计算结果保存下来，用空间换时间，减少重复计算。时间复杂度 = O((amount * coins.length)²)

3)在记忆搜索的基础上，优化成动态规划，规划好路径，消除重复计算。和记忆搜索一样，用空间换时间。

时间复杂度O(amount * coins.length)

2.暴力搜索法

暴力搜索即用穷举法解决，穷举每一种可能再累加，基于示例1来看

1)结果 = 当不用coins[0]硬币时的组合数 +

使用1个coins[0]硬币时的组合数 +

使用2个coins[0]硬币时的组合数 +

...

使用5个coins[0]硬币时的组合数。

2)不使用coins[0]硬币 = 不使用coins[1]硬币 +

使用1个coins[1]硬币 +

使用2个coins[1]硬币+

...

对每个子项累加等于amount时返回1，否则0

可以用amount累减来代替累加

代码如下：

public void solveCutCoin(int[] coins, int amount){

System.out.println(codeCutCoin(coins, 0, amount));

}

//返回coinArr[index...N-1]种硬币的分割方法

public int codeCutCoin(int[] coins, int index, int amount){

//baseCase

int res = 0;

//如果是最后一种硬币，并且amount=0

if (index >= coins.length){

res = 0 == amount ? 1 : 0;

return res;

}

//用amount-硬币面值 代替累加。

for(int i = 0; i* coins[index]<= amount; i++){

res += codeCutCoin(coins, index+1, amount -i* coins[index]);

}

return res;

}

3.记忆搜索法

分析：记忆搜索方法就是将暴力法里的计算结果存储起来，用空间换时间的方法，需要进行以下两步修改：

1)方法中有两个变量index和amount，所以新建一个

int counts = new int[coins.length][amount]，

为了方便边界处理，可以建[coins.length+1][amount+1]的。

counts[i][j]指用coins[i]...coins[n-1]这几种硬币，可以组成 j 金额的组合数

2)在取值的时候，先判断[index][amount]对应位置的值是否计算过，

(1)如果计算过，直接使用；

(2)没计算过，计算后将值记录下来。

Java中int数组默认值为0，为了区分是没计算过，还是组合数为0，我们将组合数为0的位置赋值-1，取用时判断是-1返回0。

代码如下:

//记忆搜索方法

public void solveCutCoin2(int[] coins, int aim){

int[][] count = new int[coins.length+1][aim+1];

System.out.println(codeCutCoin2(coins, 0, aim, count));

}

public int codeCutCoin2(int[] coins, int index, int amount, int[][] counts){

//baseCase

int res = 0;

if (index >= coins.length){

res = 0 == amount ? 1 : 0;

return res;

}

//当前位置值不为0，表示计算过，直接使用

if (0 != counts[index][amount]){

return (-1 == counts[index][amount]) ? 0 : counts[index][amount];

}

//计算当前位置的值

int count;

for(int i = 0; i* coins[index]<= amount; i++){

//先判断是否计算过

count = counts[index+1][amount -i* coins[index]];

if (0 != count){

res += (-1 == count) ? 0 : count;

}else {

//没计算过，重新计算

res += codeCutCoin2(coins, index+1, amount -i* coins[index], counts);

}

}

//将每次计算过的值保存，用-1标记组合数为0的位置

counts[index][amount] = (0 == res) ? -1 : res;

return res;

}

4.动态规划

分析：动态规划是将一个问题化简为子问题，通过子问题的最优解，组成整体最优，要理解整个过程，首先我们得画个图，分析一下暴力搜索的过程。

暴力搜索：

表格填充的数值为：只用coins[i]有多少种组合得到amount[j]，非0即1.

第二行的取值为下面公式的值， 图1此时index=0，coins[index]=1

counts[index+1][amount -i* coins[index]];

为了帮助理解我特意画了两个图，示例1画出的图很多细节没法展示出来。

初始化

搜索完成后

上面两张图是从右上角点往下求的，由于解法和硬币面值顺序无关，我们同样可以从下往上求，图2初始index=2, coins[index]=5, amount=10

counts[index-1][amount -i* coins[index]];

如下图所示：

自下而上搜索

我们根据面两个图继续分析，已知：

总组合数：counts[i][j] = 使用0枚5元硬币：counts[i-1][j]

+使用1枚5元：counts[i-1][j-coins[i] * 1]

...

+使用n枚5元：counts[i-1][j-coins[i] * n ]

即枚举他前一排黄色格子累加

我们发现

counts[i][j-coins[i] * 1] = count[i-1][j-coins[i] * 1]

+counts[i-1][j-coins[i] * 2]

...

+counts[i-1][j-coins[i] * n]

所以

counts[i][j] = counts[i][j-coins[i] * 1] + counts[i-1][j]

将公式套到上面两个表格，结果成立。

至此，动态规划的思路已经出来了，上面的一大串确实很繁琐，但理解后还是很简单的。其实动态规划就是对暴力搜索的一种化简，使得计算更高效。

只要列举出可能性，解决了counts[i][j] = 什么 + 什么，大部分问题也就迎刃而解了。

代码实现：

//动态规划

public void solveCutCoin3(int[] coinArr, int aim){

int[][] counts = new int[coinArr.length][aim+1];

System.out.println(codeCutCoin3(coinArr, coinArr.length-1, aim, counts));

}

public int codeCutCoin3(int[] coins, int index, int amount, int[][] counts){

//baseCase

if (0 == amount){

return 1;

}

if (index < 0 || amount < 0){

return 0;

}

if (0 == counts[index][amount]){

int res = codeCutCoin3(coins, index-1, amount, counts)

+ codeCutCoin3(coins, index, amount - coins[index], counts);

counts[index][amount] = (0 == res) ? -1 : res;

}

return -1 == counts[index][amount] ? 0 : counts[index][amount];

}

再上一张动态规划的路径截图：

image.png

5.大神的解法

上面解法看似已经很好了，但是在大神眼里这什么都不是，leetCode评论区里的解法，时间复杂度O(coins.length * amount), 空间复杂度O(amount)

在绝对的实力面前，瑟瑟发抖。

我们来看看大神的解法：

image.png

6.谈一谈怎么写递归

很多人可能觉得递归函数很难写，事实也如此。递归函数要求每一步都高度一致，很难一步到位，所以不妨分成几个步骤，逐个突破。我写递归一般有4个步骤：

1)确定需要的信息，如组合数

2)写出BaseCase，即在什么情况下不需要递归，返回确定值

3)将递归函数当做黑盒使用

4)解黑盒，将需要的信息返回给上一个调用者