动态规划-货币问题
题目一
arr是货币数组,其中的值都是正数。再给定一个正数aim。每个值都认为是一张货币,即便是值相同的货币也认为每一张都是不同的,返回组成aim的方法数。例如 : arr = { 1,1,1 },aim = 2,第0个和第1个能组成2,第1个和第2个能组成2,第0个和第2个能组成2,一共3种方法,所以返回3
从递归入手,对于每一个货币,要么选,要么不选,那么递归代码如下:
cpp
int MethodCount1(vector<int>& arr, int aim) {
return process1(arr, aim, 0, 0);//从0位置开始的总方法数
}
int process1(vector<int>& arr, int aim, int curIndex, int total) {
if (total == aim) {
return 1;
}
if (total > aim || curIndex == arr.size()) {
return 0;
}
//1.选择当前位置
int p1 = process1(arr, aim, curIndex + 1, total + arr[curIndex]);
//2.不选
int p2 = process1(arr, aim, curIndex + 1, total);
return p1 + p2;
}
其中process1的参数含义如下:
- curIndex:表示当前正在arr的curIndex位置做决策(是否选择curIndex位置的货币)
- total:表示在curIndex之前做的决策已经积累了多少货币
递归终止条件:
- total==aim,表示当前来到curIndex位置是,前面做的决策组成的总货币数量正好等于title,可以直接返回1,表示前面做的决策是正确的,同时后面不应该继续决策(否则total会大于aim)
- total>aim,表示前面做的决策是错误的,返回0种方法
- total<aim,但是curIndex到达末尾位置,表示前面做的决策不能凑到aim的货币,返回0
当来到某一个位置时,可以选择使用当前位置的货币,对应p1,也可以选择不使用当前位置的货币,对应p2,然后在到下一个为止去做选择,这是2种不同的选择,所以总的方法数为p1+p2
递归过程中是否存在重复子过程?
具有重复子过程的递归才有改动态规划的意义,上面的递归过程是可能存在重复子过程的,以[1,1,1,2,5,3],aim=7为例,可以选择下标为0和下标为1位置的1,不选择下标为2位置的1,于是就来到了下标为3的位置,此时total=2;也可以选择下标为1和下标为2位置的1,不选择下标为0位置的1,也来到了下标为3的位置,total=2,来到下标为3的位置,total=2出现了重复,因此上述递归过程存在重复子过程,改动态规划有利可图
动态规划
-
分析可变参数的变化范围,在递归过程中,可变参数只有2个,curIndex和total,curIndex的变化范围是[0,arr.size()],total的变化范围是[0,aim],在递归过程中,虽然可能存在total>aim的情况,但是此时的返回值是确定的,为0,可以在改动态规划时进行边界判断,因此dp表的大小为
arr.size()*aim
-
分析位置依赖,从递归过程可以看出,
process1(curIndex,total)
依赖于process1(curIndex + 1, total)
和process1(curIndex + 1, total + arr[curIndex])
,反应到dp表中就是当前行只依赖于下一行的数据,因此在填表时从最后一行开始填即可 -
状态转移方程,递归的过程就是状态转移方程,
process1(curIndex,total)
依赖于process1(curIndex + 1, total)
和process1(curIndex + 1, total + arr[curIndex])
,所以状态转移方程就是dp[i][j]=dp[i+1][j]+dp[i+1][j+arr[i]]
-
初始化,dp表的初始化就是递归过程的临界条件,当total==aim的时候,无论curIndex为和值,结果都是1,当total!=aim,total > aim || curIndex == arr.size()时,结果是0
-
动态规划代码:
cppint MethodCount1dp(vector<int>& arr, int aim) { //可变参数为curIndex和total //curIndex->[0,arr.size()] //total->[0,aim],因为当total>aim时返回0 vector<vector<int>> dp(arr.size() + 1, vector<int>(aim + 1)); for (int curIndex = 0; curIndex <= arr.size(); curIndex++) { dp[curIndex][aim] = 1;//total==aim时 } for (int curIndex = arr.size() - 1; curIndex >= 0; curIndex--) {//从最后一行开始填表 for (int total = 0; total < aim; total++) { //total从左往后或从右往左填无所谓 //循环条件为total<aim,因为total==aim时结果为1 int p1 = total + arr[curIndex] > aim ? 0 : dp[curIndex + 1][total + arr[curIndex]];//对total + arr[curIndex]>aim的情况进行特殊处理,根据递归郭晨可知,大于aim时结果为0 int p2 = dp[curIndex + 1][total]; dp[curIndex][total] = p1 + p2; } } return dp[0][0];//主函数调用process1(arr, aim, 0, 0),因此返回dp[0][0] }
题目二
arr是面值数组,其中的值都是正数且没有重复。再给定一个正数aim。每个值都认为是一种面值,且认为张数是无限的。返回组成aim的方法数例如︰arr = {1,2}, aim = 4。方法如下∶1 + 1 + 1 + 1、1 + 1 + 2、2 + 2一共3种方法,所以返回3。
递归过程与题目1类似,均为从左往右的尝试模型,只是每一种面值都可以选择无限多张,在递归时需要注意选择的总面额要<=aim,递归过程:
cpp
int MethodCount2(vector<int>& arr, int aim) {
//暴力递归:每一个位置可以选择多次
return process2(arr, 0, aim);//当前在0位置,还需要凑齐aim元的方法
}
int process2(vector<int>& arr, int Index, int rest) {
if (rest == 0) {
return 1;
}
if (Index == arr.size()) {//不会出现aim<0的情况,因为在for循环中已经避免
return 0;
}
int ans = 0;
//当前位置可以选很多次
for (int cnt = 0; cnt * arr[Index] <= rest; cnt++) {
ans += process2(arr, Index + 1, rest - (cnt * arr[Index]));
}
return ans;
}
参数含义:
- Index,表示当前正在Index位置做决策
- rest,还需要凑总计rest价值的面额,当rest==0时表示不需要凑面额了,也就是找到了一种方法。第二个参数也可以定义为目前已经凑到的面额数,这样就与题目1一样,只要逻辑上合理即可
递归过程:
- 当rest==0时,表示还需要凑0价值的面额,表示前面所做的决策是正确的,找到了1种方法
- rest>0&&Index == arr.size(),表示已经达到结尾,但是还有rest面额需要去凑,此时返回0
- rest>0&&Index < arr.size(),此时可以选择自由选择Index位置的面额,可以选1次、2次、......,不过需要注意的是,选择n次之后rest应该保证大于0,例如需要凑5元的面值,不能选6张1块的,通过
cnt * arr[Index] <= rest
可以保证这一点 - 递归过程中不可能出现rest<0的情况,因为主函数在调用process2时传入的rest一定大于0,在process2中,for循环内调用process2也保证了rest>=0,因此整个过程rest>=0
动态规划
在process2过程中,process2(Index,rest)依赖于process2(Index+1,......),当前行只依赖于下一行的数据,因此在填dp表时,从最后一行开始填
cpp
int MethodCount2dp(vector<int>& arr, int aim) {
//Index->[0,arr.size()]
//rest->[0,aim]
vector<vector<int>> dp(arr.size() + 1, vector<int>(aim + 1));
for (int i = 0; i <= arr.size(); i++) {
dp[i][0] = 1;//rest==0,return 1
}
for (int Index = arr.size() - 1; Index >= 0; Index--) {
for (int rest = 1; rest <= aim; rest++) {//rest==0已经填过了
int ans = 0;
for (int cnt = 0; cnt * arr[Index] <= rest; cnt++) {
ans += dp[Index + 1][rest - (cnt * arr[Index])];
}
dp[Index][rest] = ans;
}
}
return dp[0][aim];
}
分析位置依赖
在动态规划方法的填表过程中,确定一个位置需要通过for循环完成,我们可以画出位置依赖图
假设rest=7,当前来到2号下标做选择,arr[2]=3,那么根据for循环代码,(rest,Index)位置依赖于下一行的图示位置A、B和C,同时还可以观察出(rest-arr[Index],Index)依赖于下一行的A和B,所以一个位置实际上依赖于它左边的位置和它下方的位置,因此动态规划的状态转移方程可以简化为dp[Index][rest]=dp[Index+1][rest]+dp[Index][rest-arr[Index]](需要处理边界)
,这是通过分析位置依赖得出的结论。所以上面的代码可以改写为:
cpp
int MethodCount2dp(vector<int>& arr, int aim) {
vector<vector<int>> dp(arr.size() + 1, vector<int>(aim + 1));
for (int i = 0; i <= arr.size(); i++) {
dp[i][0] = 1;
}
for (int Index = arr.size() - 1; Index >= 0; Index--) {
for (int rest = 1; rest <= aim; rest++) {//rest==0已经填过了
dp[Index][rest]=dp[Index+1][rest];
if(rest-arr[Index]>=0){
dp[Index][rest]+=dp[Index][rest-arr[Index]];
}
}
}
return dp[0][aim];
}
题目三
arr是货币数组,其中的值都是正数。再给定一个正数aim。每个值都认为是一张货币,认为值相同的货币没有任何不同,返回组成aim的方法数。例如 : arr = {1,2,1,1,2,1,2}, aim = 4,方法∶1 + 1 + 1 + 1、1 + 1 + 2、2 + 2一共就3种方法,所以返回3
题目3中需要统计出每种面值出现的次数,递归过程也是采用从左往右进行尝试
cpp
int MethodCount3(vector<int>& arr, int aim) {
vector<int> counts;//统计张数
vector<int> money;
unordered_map<int, int> hashMap;
for (int m : arr) {
hashMap[m]++;
}
for (auto [m, c] : hashMap) {
money.push_back(m);
counts.push_back(c);
}
return process3(money, counts, 0, aim);
}
int process3(vector<int>& money, vector<int>& counts, int Index, int rest) {
if (rest == 0) {
return 1;
}
if (Index == money.size()) {
return 0;//rest>0
}
int ans = 0;
for (int cnt = 0; cnt <= counts[Index] && rest - cnt * money[Index] >= 0; cnt++) {
ans += process3(money, counts, Index + 1, rest - cnt * money[Index]);
}
return ans;
}
与题目2不同的是,题目3中的for循环除了保证rest减完之后大于0,还要保证在Index位置使用的货币数量不能超过原数组中对应的面值数量。
动态规划
由递归过程可以比较容易的改出动态规划版本
cpp
int MethodCount3dp(vector<int>& arr, int aim) {
vector<int> counts;
vector<int> money;
unordered_map<int, int> hashMap;
for (int m : arr) {
hashMap[m]++;
}
for (auto [m, c] : hashMap) {
money.push_back(m);
counts.push_back(c);
}
vector<vector<int>> dp(money.size() + 1, vector<int>(aim + 1));
for (int i = 0; i <= money.size(); i++) {
dp[i][0] = 1;
}
for (int Index = money.size() - 1; Index >= 0; Index--) {
for (int rest = 0; rest <= aim; rest++) {
int ans = 0;
for (int cnt = 0; cnt <= counts[Index] && rest - cnt * money[Index] >= 0; cnt++) {
ans += dp[Index + 1][rest - cnt * money[Index]];
}
dp[Index][rest] = ans;
}
}
return dp[0][aim];
}
分析位置依赖
假设来到Index=2位置做决策,并假设此时rest=11,money[2]=3,counts[2]=2,则位置依赖如图:
通过观察可以发现:dp[Index][rest]=dp[Index+1][rest]+dp[Index][rest-money[Index]]-O点(需要对边界进行额外处理)
,O点的坐标为(Index+1,rest-(counts[Index]+1)*money[Index])。优化代码:
cpp
int MethodCount3dp2(vector<int>& arr, int aim) {
vector<int> counts;
vector<int> money;
unordered_map<int, int> hashMap;
for (int m : arr) {
hashMap[m]++;
}
for (auto [m, c] : hashMap) {
money.push_back(m);
counts.push_back(c);
}
vector<vector<int>> dp(money.size() + 1, vector<int>(aim + 1));
for (int i = 0; i <= money.size(); i++) {
dp[i][0] = 1;
}
for (int Index = money.size() - 1; Index >= 0; Index--) {
for (int rest = 0; rest <= aim; rest++) {
dp[Index][rest] = dp[Index + 1][rest];
if (rest - money[Index] >= 0) {
dp[Index][rest] += dp[Index][rest - money[Index]];
}
if (rest - (counts[Index] + 1) * money[Index] > 0) {
dp[Index][rest] -= dp[Index + 1][rest - (counts[Index] + 1) * money[Index]];
}
}
}
return dp[0][aim];
}
总结
有重复子过程的递归可以尝试将其改写为动态规划,这样会使得解决问题的时间复杂度大大减小,动态规划的状态转移方程其实就是递归的尝试过程,dp表的初始化就是递归的出口,dp表的填表顺序取决于尝试策略,在填表时,若确定dp表的一个位置需要使用for循环,应该尝试分析递归过程和位置依赖,以确定是否可以做进一步的优化。