接着上道题,这道题也是用来感受暴力递归优化成动态规划的套路。先想暴力尝试的方法,然后优化成动态规划。首先是原问题的暴力尝试方法。只有想出尝试方法是最难、最重要的。
我们首先来看一下题目:
给你一个数组arr,arr中所有的值都为正数且不重复,和一个整数aim。如果可以任意选择arr中的数字,每个数字只能选一次,能不能累加得到aim,返回true或者false。
思路类似字符串的子序列问题:令f(i,sum)中的i表示数组下标,sum表示数组最开始元素到当前元素的和,以arr={3,2,7,13},aim=9为例,则递归过程如下图所示:(PS:这是一张只有本人看得懂的图,o(╯□╰)o)
所以解决步骤如下:
1.写出尝试(递归)版本
public static boolean money1(int[] arr, int aim) {
return process1(arr, 0, 0, aim);
}
public static boolean process1(int[] arr, int i, int sum, int aim) {
if (i == arr.length) {
return sum == aim;
}
//继续往下执行,两种情况:要么选要么不选
return process1(arr, i + 1, sum, aim) || process1(arr, i + 1, sum + arr[i], aim);
}
2. 分析是否满足转动态规划的条件:
(1).存在大量重复计算:上述例子不够清楚,可以换成{3,2,5,13},则到第三步将会出现两个f(3,5),一个是由f(2,5)+0,一个是由f(2,0)+5所得,而f(3,5)的后续返回值肯定相同,所以存在重复计算。
(2).该问题属于“无后效性”问题:同1,不管哪条路径到达的f(3,5),得到的返回值都一样,则表示为“无后效性”。
综述所述,可以转为动态规划。
3. 分析可变参数,哪几个可变参数的值能代表返回状态,几个可变参数,以及它们的变化范围,即可构造几维dp表。
数组和aim不可变,i,sum可变。
4.看base case,列出不依赖的位置。(以数组{3, 2, 5 },aim=7为例,减少工作量)
二维表行代表i,列代表sum即全部元素的和(aim原则上不会超过这个数,如果超过了很显然返回false)。
可知base case为最后一行,只有当sum==aim的时候才是T,其它都是F。所以可得下表内容:
I \ SUM | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0 | |||||||||||
1 | |||||||||||
2 | |||||||||||
3 | F | F | F | F | F | F | F | T | F | F | F |
5.分析一个普遍位置的依赖。
return process1(arr, i + 1, sum, aim) || process1(arr, i + 1, sum + arr[i], aim);
可知,要知道一个普遍位置的值,就得知道它的下一行的值和下一行并向右加arr[i]列的值。例如f(2,0),根据上述代码可知,依赖于f(3,0)和f(3,5),所以f(2,0)为F(因为f(3,0)和f(3,5)都为F)。
综述所述,最后一行知道了,反过来就能填完了整张表。
I \ SUM | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0 | T | F | T | F | T | T | F | T | F | F | F |
1 | T | F | T | F | F | T | F | T | F | F | F |
2 | F | F | T | F | F | F | F | T | F | F | F |
3 | F | F | F | F | F | F | F | T | F | F | F |
整体代码如下:
package com.gxu.dawnlab_algorithm8;
/**
* 换钱问题
*
* @author junbin
*
* 2019年7月12日
*/
public class Money_Problem {
public static boolean money1(int[] arr, int aim) {
return process1(arr, 0, 0, aim);
}
public static boolean process1(int[] arr, int i, int sum, int aim) {
if (sum == aim) { //如果遍历过程中满足该条件,则停止后续遍历
return true;
}
// sum != aim
if (i == arr.length) { //如果已经到了数组末尾,则直接输出
return false;
}
//继续往下执行,两种情况:要么选要么不选
return process1(arr, i + 1, sum, aim) || process1(arr, i + 1, sum + arr[i], aim);
}
//动态规划
public static boolean money2(int[] arr, int aim) {
boolean[][] dp = new boolean[arr.length + 1][aim + 1];//列改为aim+1可以更节省空间
for (int i = 0; i < dp.length; i++) {
dp[i][aim] = true;
}
for (int i = arr.length - 1; i >= 0; i--) {
for (int j = aim - 1; j >= 0; j--) {
dp[i][j] = dp[i + 1][j];
if (j + arr[i] <= aim) {
dp[i][j] = dp[i][j] || dp[i + 1][j + arr[i]];
}
}
}
return dp[0][0];
}
public static void main(String[] args) {
int[] arr = { 1, 4, 8 };
int aim = 12;
System.out.println(money1(arr, aim));
System.out.println(money2(arr, aim));
}
}
总结:到现在已经体验了两道暴力递归转动态规划的经典题目了,可以感觉到高度的套路化,但是仍然觉得很不熟练,特别是最难的写出尝试版本和画出dp表阶段,继续加油!