通过对换钱类题目的学习，我们将了解到

暴力递归及优化方法

记忆搜索(优化一)

动态规划的基本实现方法(优化二)

动态规划的空间优化(优化三)

1. 换钱的最少货币数，货币可重复使用

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

例如

arr=[5, 2, 3], aim=20, 返回4

arr=[5, 2, 3], aim=0, 返回0

arr=[3, 5], aim=2, 返回-1

动态规划方法的关键是构造动态规划表dp。

动态规划的实质就是在计算过程中，根据动态规划表计算下一个目标值，并更新动态规划表

在本题中，构造这样二维动态规划表，dp[i][j]，其中，i j的含义如下：

i: 代表可以使用的货币种类为 arr[0..i]

j: 代表需要兑换的面值数，其取值范围为[0..aim]，因此实现时，二维数组的列数应该为aim + 1

构造过程：

构造边界值。边界值是更新规划表的起始值，也是很容易犯错的地方，需要谨慎设置起始边界值。

dp[0..N-1][0]：规划表的第一列值，表示当需要兑换0元时，需要的货币数，显然货币数为0，直接设置为0.

dp[0][0..aim]：规划表的第一行值，表示只使用arr[0]一种货币兑换[0..aim]时，需要的货币数，因此，只要tmp_aim可以被arr[0]整除，返回整除后的数，即为对应的值。在下面的实现中，我们使用了更为通用的方法来得到规划表的第一行的值，可以根据下面的算法，理解一下实现中的计算方法。

更新动态规划表

更新方向：逐行更新，每行从左到右更新。

更新值：对于dp[i][j]，更新的依据有两个值，一个是“不使用当前种类的货币时，组成总数的j的最小方法，即dp[i-1][j]”，另外一个是“使用并且仅使用一张当前种类的货币时，组成总数的j的最小方法，即 dp[i][j-arr[i]] + 1”，取这两个值中的最小值即为dp[i][j]的值。

关于依据中的第二个值，可以通过公式推导得到。可以查看文末的参考资料详细了解。

实现

class Solution

{

public:

int ExchangeMoney(std::vector& arr, uint32_t aim);

};

int Solution::ExchangeMoney(std::vector& arr, uint32_t aim)

{

// fix: precheck

if (arr.size() == 0 || aim == 0)

{

return 0;

}

int arrSize = arr.size();

int dp[arrSize][aim + 1];

for (uint32_t lineIndex = 0; lineIndex < arrSize; ++lineIndex)

{

dp[lineIndex][0] = 0;

}

for (uint32_t rowIndex = 1; rowIndex < aim + 1; ++rowIndex)

{

// 动态初始化边界值的方法

if (int(rowIndex - arr[0]) >= 0 && dp[0][rowIndex - arr[0]] != UINT32_MAX)

{

dp[0][rowIndex] = dp[0][rowIndex - arr[0]] + 1;

}

else

{

dp[0][rowIndex] = UINT32_MAX;

}

}

for (uint32_t lineIndex = 1; lineIndex < arrSize; ++lineIndex)

{

for (uint32_t rowIndex = 1; rowIndex < aim + 1; ++rowIndex)

{

int subCurArrValue = rowIndex - arr[lineIndex];

uint32_t upValue = dp[lineIndex - 1][rowIndex];

uint32_t leftValue = UINT32_MAX;

if (subCurArrValue >= 0 && dp[lineIndex][subCurArrValue] != UINT32_MAX)

{

leftValue = dp[lineIndex][subCurArrValue] + 1;

}

dp[lineIndex][rowIndex] = leftValue < upValue ? leftValue : upValue;

}

}

return dp[arrSize - 1][aim] == UINT32_MAX ? -1 : dp[arrSize - 1][aim];

}

2. 动态规划的空间优化

上面的实现，需要的空间复杂度是O(N * aim)，下面的方法，可以将空间复杂度优化到O(aim)。

优化方法：

生成一个一维动态规划数组dp[aim + 1]

构造初始值：参考上面的方法，初始值表示只使用arr[0]一种货币时，兑换[0..aim]的最少货币数。

更新动态规划表：更新方向，从左到右更新。对于dp[j]，更新的依据有两个，一个是 dp[j](old)，换算成二维数组，即为不使用arr[j]货币时的最少货币数，即为dp[line-1][j]。另外一个是dp[j-arr[j]] + 1，即为“使用并且仅使用一张当前种类的货币时的最少货币数”，换算成二维数组，即为dp[line][j-arr[j]] + 1.

实现

int Solution::ExchangeMoney(std::vector& arr, uint32_t aim)

{

if (arr.size() == 0 || aim == 0)

{

return 0;

}

int arrSize = arr.size();

int dp[aim + 1]; // updated by line

dp[0] = 0; // first element is always 0

for (uint32_t rowIndex = 1; rowIndex < aim + 1; ++rowIndex)

{

if (int(rowIndex - arr[0]) >= 0 && dp[rowIndex - arr[0]] != UINT32_MAX)

{

dp[rowIndex] = dp[rowIndex - arr[0]] + 1;

}

else

{

dp[rowIndex] = UINT32_MAX;

}

}

for (uint32_t lineIndex = 1; lineIndex < arrSize; ++lineIndex)

{

for (uint32_t rowIndex = 1; rowIndex < aim + 1; ++rowIndex)

{

int subCurArrValue = rowIndex - arr[lineIndex];

uint32_t upValue = dp[rowIndex];

uint32_t leftValue = UINT32_MAX;

if (subCurArrValue >= 0 && dp[subCurArrValue] != UINT32_MAX)

{

leftValue = dp[subCurArrValue] + 1;

}

dp[rowIndex] = leftValue < upValue ? leftValue : upValue;

}

}

return dp[aim] == UINT32_MAX ? -1 : dp[aim];

}

从上面的实现，我们可以看到，我们将二维动态规划表压缩成一维动态规划表，依据是：

对于表中的每个元素，我们只会在更新下一个值时，使用一次，之后便不再使用。

更新下一个值，依赖“向左跳一次”和“向上跳一位”，而这两个数可以在一维动态规划表中保存。如果依赖多个“向上跳”的值，则无法使用一维动态规划表实现空间优化。

3. 还钱的最少货币数，货币不可重复使用

给定数组arr，arr中所有的值都为正数。每个值仅代表一张钱的面值，再给定一个数aim代表要找的钱数，求组成aim的最少货币数。

例如

arr = [5, 2, 3], aim = 20，无法组成，返回-1

arr = [5, 2, 5, 3], aim = 10，返回2

arr = [5, 2 ,5 ,3], aim = 15，返回4

arr = [5, 2, 5, 3], aim = 0，返回0

构造二维动态规划表dp[i][j]，i表示可以使用货币arr[0..i]，j表示组成的货币总数。

构造过程

构造边界值

dp[0..N-1][0]：规划表的第一行值，表示当前需要兑换0元时需要的货币数，显然货币数为0，直接设置为0

dp[0][0..aim]：规划表的第一列，表示仅使用arr[0]一种货币兑换[0..aim]时，是否可以兑换，如果arr[0]就等于j，则dp[0][j] = 1，否则等于UINT32_MAX，表示无法兑换。

更新动态规划表

更新方向：逐行更新，每行从左到右更新。

更新值：对于dp[i][j]，更新的依据有两个值，一个是“不适用当前面值的货币时，组成总数j的最少方法，即dp[i-1][j]“，另一个是”使用当前面值的货币时，组成总数j的最少方法，即dp[i-1][j-arr[j]] + 1“，取这两个值中的最小值即为dp[i][j]的值。

这里同样可以用一维动态规划表对空间优化到O(aim)。

实现的思路基本和上面两例一样。

4 换钱的方法数，可重复使用

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

例如

arr = [5, 10, 25, 1], aim = 0，返回1

arr = [5, 10, 25, 1], aim = 15，返回6

arr = [3, 5]，aim = 2，返回0

暴力递归法

递归终止条件：aim == 0

循环条件：使用当前面值货币0..k张，其中 k * arr[curIndex] <= aim

递归：对每个面值的货币，返回组成余下aim的方法数

int Solution::ExchangeMoney(std::vector& arr, uint32_t aim)

{

if (aim == 0)

{

return 1;

}

if (arr.size() == 0)

{

return 0;

}

return process(arr, 0, aim);

}

int Solution::process(std::vector& arr, uint32_t index, uint32_t aim)

{

int ret = 0;

if (index == arr.size())

{

ret = 0 == aim ? 1 : 0;

}

else

{

for (uint32_t k = 0; k * arr[index] <= aim; ++k)

{

ret += process(arr, index + 1, aim - k * arr[index]);

}

}

return ret;

}

记忆搜索法

上面的暴力递归法，存在着大量的重复计算。

优化方法是将中间结果保存下来，在下一次计算的时候，查看表中是否已经有结果。

int Solution::ExchangeMoney(std::vector& arr, uint32_t aim)

{

if (aim == 0)

{

return 1;

}

if (arr.size() == 0)

{

return 0;

}

std::map<:pair>, uint32_t> resultMap;

return process(arr, 0, aim, resultMap);

}

int Solution::process(std::vector& arr, uint32_t index, uint32_t aim,

std::map<:pair uint32_t>, uint32_t>& resultMap)

{

int ret = 0;

if (index == arr.size())

{

ret = 0 == aim ? 1 : 0;

}

else

{

for (uint32_t k = 0; k * arr[index] <= aim; ++k)

{

uint32_t nextIndex = index + 1;

uint32_t nextAim = aim - k * arr[index];

std::map<:pair uint32_t>, uint32_t>::iterator it = resultMap.find(std::make_pair(nextIndex, nextAim));

if (it != resultMap.end())

{

ret += it->second;

}

else

{

ret += process(arr, nextIndex, nextAim, resultMap);

}

}

}

return ret;

}

动态规划

构造二维动态规划表dp[i][j]

构造边界值

dp[0][0..j]，动态规划表第一行，表示只使用arr[0]一个种类的货币时，可以兑换货币总数j的方法数，无法兑换时，则设置为0。

dp[0..N-1][0]，动态规划表第一列，表示兑换货币总数0的方法数，设置为1.

更新动态规划表

dp[i][j]的取值依据有两个，第一个是，"不使用当前面值的货币时，组成货币总数的方法数，dp[i-1][j]"，第二个是，”分别使用1..k张当前面值的货币时，组成货币总数的方法数之和，由公式可以推导出，该值为dp[i][j-arr[i]]“，dp[i][j] = dp[i-1][j] + dp[i][j - arr[i]]。

代码实现请参考上面的几例，稍加需改即可得出。

参考资料

《程序员代码面试指南：IT名企算法与数据结构题目与最优解》