通过对换钱类题目的学习，我们将了解到
- 暴力递归及优化方法
- 记忆搜索（优化一）
- 动态规划的基本实现方法（优化二）
- 动态规划的空间优化（优化三）
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, uint32_t> resultMap;
return process(arr, 0, aim, resultMap);
}
int Solution::process(std::vector& arr, uint32_t index, uint32_t aim,
std::map, 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, 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名企算法与数据结构题目与最优解》