接着上道题，这道题也是用来感受暴力递归优化成动态规划的套路。先想暴力尝试的方法，然后优化成动态规划。首先是原问题的暴力尝试方法。只有想出尝试方法是最难、最重要的。
我们首先来看一下题目：
给你一个数组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表阶段，继续加油！
