暴力递归：
1，把问题转化为规模缩小了的同类问题的子问题
2，有明确的不需要继续进行递归的条件(base case)
3，有当得到了子问题的结果之后的决策过程
4，不记录每一个子问题的解
动态规划
1，从暴力递归中来
2，将每一个子问题的解记录下来，避免重复计算
3，把暴力递归的过程，抽象成了状态表达
4，并且存在化简状态表达，使其更加简洁的可能
一：递归
1. 汉诺塔问题
汉诺塔问题（不能大压小，只能小压大），打印n层汉诺塔从最左边移动到最右边的全部过程。
左中右另称为 from、to、help。
划分子问题：
1、先把1~n-1从from移动到help；
2、把单独的n移动到to；
3、1~n-1从help移动到to；
时间复杂度就是：T(n) = T(n-1) + 1 + T(n-1) = 2T(n-1)+1（一个等比公式）。T(n-1)是移动到help；1是从from直接移动到to；T(n-1)是把全部n-1挪回去。总的步数是2的N次方减一。
2. 打印一个字符串的全部子序列，包括空字符串
例如：一个字符串awbcdewgh
他的子串:awbc,awbcd,wbcde...很多个子串,但是都是连续在一起
他的子序列:abc,abcd,abcde...很多个子序列,但是子序列中的字符在字符串中不一定是连在一起的
所以 子串!=子序列
思路：穷举，例如“abc”,一开始返回串res是空字符串，经过第0次，产生有’a’字符的路径和没有’a’字符的路径，经过第1次时，也决定是否有‘b’字符的路径，依次往复，列举所有路径。
1 public class Code_03_Print_All_Subsquences { 2 3 public static void printAllSubsquence2(String str) { 4 char[] chs = str.toCharArray(); 5 process(chs,0); 6 } 7 8 private static void process(char[] chs, int i) { 9 if (i == chs.length) { 10 System.out.print(String.valueOf(chs)+"|"); 11 return; 12 } 13 process(chs, i+1);//有该字符 14 char temp = chs[i]; 15 chs[i] = 0;//将该字符设置成null 16 process(chs, i+1); 17 chs[i] = temp;//复原该字符 18 } 19 20 public static void printAllSub1(char[] str, int i, String res) { 21 if (i==str.length) { 22 System.out.print(res+"|"); 23 return; 24 } 25 // printAllSub1(str, i+1, res);放在这也可以 26 //有该字符的路 27 printAllSub1(str, i+1, res+String.valueOf(str[i])); 28 //没有该字符的路 29 printAllSub1(str, i+1, res); 30 } 31 32 private static void test() { 33 char[] chs = {'a','b','c','d'}; 34 String res = ""; 35 System.out.print("printAllSub1:"); 36 printAllSub1(chs, 0, res); 37 System.out.print(" printAllSubsquence2:"); 38 printAllSubsquence2("abcd"); 39 } 40 public static void main(String[] args) { 41 test(); 42 43 } 44 }
结果：
3. 打印一个字符串的全部排列，没有重复排列
1 /** 打印一个字符串的全部排列*/ 2 public class Code_04_Print_All_Permutations { 3 4 public static void printAllPermutations1(String str) { 5 char[] chs = str.toCharArray(); 6 process1(chs, 0); 7 } 8 9 public static void process1(char[] chs, int i) { 10 if (i==chs.length) { 11 System.out.println(String.valueOf(chs)); 12 return; 13 } 14 for (int j = i; j < chs.length; j++) { 15 swap(chs,i,j); 16 process1(chs, i+1); 17 swap(chs, i, j);//要交换过来； 18 } 19 } 20 public static void printAllPermutations2(String str) { 21 char[] chs = str.toCharArray(); 22 process1(chs, 0); 23 } 24 25 private static void swap(char[] chs, int i, int j) { 26 char temp = chs[i]; 27 chs[i] = chs[j]; 28 chs[j] = temp; 29 } 30 31 private static void test() { 32 String test1 = "abc"; 33 printAllPermutations1(test1); 34 System.out.println("======"); 35 // printAllPermutations2(test1); 36 // System.out.println("======"); 37 } 38 public static void main(String[] args) { 39 // TODO Auto-generated method stub 40 test(); 41 } 42 }
4. 母牛数量
母牛每年生一只母牛，新出生的母牛成长三年后也能每年生一只母牛，假设不会死。求N年后，母牛的数量。
1 /* 2 * 母牛每年生一只母牛，新出生的母牛成长三年后也能每年生一只母牛，假设不会死。 3 * 求N年后，母牛的数量。 4 * 可得每年的：1,2,3,4,6,9... 5 * F(n) = F(n-1) + F(n-3) 6 * 复杂度O(N) 7 * 8 * 改进：矩阵运算O(logN) 9 * 10 */ 11 public class Code_05_Cow { 12 13 //递归 14 public static int cowNumber1(int n) { 15 if (n < 1) { 16 return 0; 17 } 18 if (n == 1 || n == 2 || n == 3) { 19 return n; 20 }else { 21 return cowNumber1(n-1)+cowNumber1(n-3); 22 } 23 } 24 //非递归 25 public static int cowNumber2(int n) { 26 if (n < 1) { 27 return 0; 28 } 29 if (n == 1 || n == 2 || n == 3) { 30 return n; 31 } 32 int cur = 3; 33 int pre = 2; 34 int prepre = 1; 35 int temp1 = 0; 36 int temp2 = 0; 37 for (int i = 4; i <=n ; i++) { 38 temp1 = cur; 39 temp2 = pre; 40 cur = cur + prepre; 41 pre = temp1; 42 prepre = temp2; 43 } 44 return cur; 45 } 46 private static void test() { 47 int i = 10; 48 System.out.print("cowNumber1:"); 49 System.out.println(cowNumber1(i)); 50 System.out.print("cowNumber2:"); 51 System.out.println(cowNumber2(i)); 52 53 } 54 public static void main(String[] args) { 55 test(); 56 57 } 58 }
5. 递归栈
1 public class Code_06_ReverseStackUsingRecursive { 2 3 public static void reverse(Stack<Integer> stack) { 4 if (stack.isEmpty()) { 5 return; 6 } 7 int temp = stack.pop(); 8 reverse(stack); 9 stack.push(temp); 10 11 } 12 private static void test() { 13 Stack<Integer> stack = new Stack<>(); 14 stack.add(1); 15 stack.add(2); 16 stack.add(3); 17 stack.add(4); 18 stack.add(5); 19 stack.add(6); 20 printStack(stack); 21 reverse(stack); 22 printStack(stack); 23 } 24 private static void printStack(Stack<Integer> stack) { 25 for (Integer i : stack) { 26 System.out.print(i+" "); 27 } 28 System.out.println(); 29 } 30 public static void main(String[] args) { 31 test(); 32 33 } 34 }
二：动态规划
1. 数组的最小路径和
给你一个二维数组，二维数组中的每个数都是正数，要求从左上角走到右下角，每一步只能向右或者向下。沿途经过的数字要累加起来。返回最小的路径和。
解题思路：到达右下角时，返回右下角的值；如果到达最后一行，则只能往右走（返回该点处值+右走的值）；如果到达最后一列，则只能往下走（返回该点处值+下走的值）；计算向右走的总值（该点处值+右走的值），计算向下走的总值（该点处值+下走的值），返回比较值。问题划分为了：向下或者向右的结果，从中选最小的路径，就是最后的答案。
1 //运用递归 2 //从左上角到右下角寻找路径 3 public static int minPath1(int[][] matrix, int i, int j) { 4 if (i == matrix.length - 1 && j == matrix[0].length - 1) { 5 return matrix[i][j]; 6 } 7 if (i == matrix.length - 1) {//到最后一行 8 return matrix[i][j] + minPath1(matrix, i, j + 1); 9 } 10 if (j == matrix[0].length - 1) {//到最后一列 11 return matrix[i][j] + minPath1(matrix, i + 1, j); 12 } 13 int right = matrix[i][j] + minPath1(matrix, i, j + 1); 14 int down = matrix[i][j] + minPath1(matrix, i + 1, j); 15 return Math.min(right, down); 16 } 17 //从右下角到左上角寻找路径 18 public static int minPath2(int[][] matrix) { 19 return process2(matrix, matrix.length - 1, matrix[0].length - 1); 20 } 21 private static int process2(int[][] matrix, int rl, int cl) { 22 if (rl == 0 && cl == 0) { 23 return matrix[rl][cl]; 24 } 25 if (rl == 0 && cl != 0) {//到第一行 26 return matrix[rl][cl] + process2(matrix, rl, cl-1); 27 } 28 if (rl != 0 && cl == 0) {//到第一列 29 return matrix[rl][cl] + process2(matrix, rl-1, cl); 30 } 31 // return matrix[rl][cl] + Math.min(process2(matrix, rl, cl-1), process2(matrix, rl-1, cl)); 32 //等同于以下三句 33 int left = matrix[rl][cl] + process2(matrix, rl, cl-1); 34 int up = matrix[rl][cl] + process2(matrix, rl-1, cl); 35 return Math.min(left,up); 36 }
以上是递归，但是复杂度过高，暴力枚举有待优化：有大量的重复解产生，很多部分都重复计算。如果把重复计算的部分缓存起来，重复的时候直接调用就能省时间，这就是动态规划。如图，当计算到(0,1)位置时，需要计算(0,2)和(1,1),而在计算(1,0)时，需要计算(1,1)和(2,0),此时，(1,1)被重复计算。
什么样的尝试版本递归可以改成动态规划？
当把递归过程展开，发现有重复的状态，与到达它的路径是没有关系的，那么它一定能改成动态规划（无后效性问题）。就本题来说，当到达某点(x,y)时，不管是从上还是从左来的，对于自己来说，从自己到达最右下角的点的最短路径是固定不变的，而与到达(x,y)该处的来源是无关的。
有后效性的是，汉罗塔、N皇后问题（前面的举动会影响后面的结果）。
【暴力递归转动态规划过程】对于法1
- 先写出尝试版本；（以从左上角到右下角为例）；
- 分析可变参数，那几个可变参数可以代表返回值的状态，可变参数是几维的，dp表就是几维的（该题是i和j二维表）；
- 看看最终要的状态是哪一个，在表中点出来（该题是（0,0）位置，五角星处）；
- 回到basecase中，把完全不依赖位置的值设置好（这题是最后一行和最后一列）；basecase代表一个问题划分到什么程度就不用再划分了（该题是最右下角的位置）。
- 分析一个普遍位置需要哪些位置（该题需要右边的值和下边的值），然后逆着回去，就是填表的顺序。依次计算，推到顶部就是答案。像搭积木一样，堆积到一定条件就能出现答案。
1 //动态规划 2 public static int minPath3(int[][] matrix) { 3 if (matrix==null || matrix.length == 0 4 || matrix[0].length == 0 || matrix[0]==null) { 5 return 0; 6 } 7 int row = matrix.length; 8 int col = matrix[0].length; 9 int[][] dp = new int[row][col]; 10 dp[0][0] = matrix[0][0]; 11 //先把dp表的边界先依次求和填充进去； 12 for (int i = 1; i < row; i++) { 13 dp[i][0] = dp[i-1][0] + matrix[i][0]; 14 } 15 for (int i = 1; i < col; i++) { 16 dp[0][i] = dp[0][i-1]+matrix[0][i]; 17 } 18 //在填充里面的各项；挑选dp表中左边和上边两者中较小的加上matrix[i][j]当前位置，填充dp[i][j]位置； 19 for (int i = 1; i < row; i++) { 20 for (int j = 1; j < col; j++) { 21 dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + matrix[i][j]; 22 } 23 } 24 return dp[row-1][col-1]; 25 }
2. 数组累加问题
给你一个数组arr，和一个整数aim。如果可以任意选择arr中的数字，能不能累加得到aim，返回true或者false。
思路：无后效性，类似于打印所有子序列，就是该位上数字加或不加；
通过分析发现，arr[]和aim是不变的，而i和sum 是变化的，i的范围是数的个数，sum是所有的数的和
1 public class Code_08_Money_Problem { 2 3 public static boolean isSum(int[] arr, int i,int sum,int aim) { 4 if (i == arr.length) { 5 return sum == aim; 6 } 7 return isSum(arr, i+1, sum, aim) || isSum(arr, i+1, sum+arr[i], aim); 8 } 9 private static void test() { 10 int[] arr = {1,4,8}; 11 int aim = 12; 12 System.out.println(isSum(arr, 0, 0, aim)); 13 } 14 public static void main(String[] args) { 15 test(); 16 } 17 }
如：arr[] = [3,2,5]
Return i+1, sum || i+1, sum+arr[i]
推理：
当(i,sum)时，需要的是(i+1,sum)和(i+1,sum+arr[i])
当(2,0)，需要的是(3,0)和(3,0+arr[2]),
…像搭积木一样
最后一行是多出来的存放结果，只有aim那一列上才
是true,其他都是false。
3. 一定条件下最大值问题
给定两个数组w和v，两个数组长度相等，w[i]表示第i件商品的重量，v[i]表示第i件商品的价值。 再给定一个整数bag，要求你挑选商品的重量加起来一定不能超 过bag，返回满足这个条件下，你能获得的最大价值。
1 public class Code_09_Knapsack { 2 3 public static int maxValue1(int[] c, int[] p, int bag) { 4 return process1(c, p, 0, 0, bag); 5 } 6 7 public static int process1(int[] weights, int[] values, int i, int alreadyweight, int bag) { 8 if (alreadyweight > bag) { 9 return 0; 10 } 11 if (i == weights.length) { 12 return 0; 13 } 14 return Math.max( 15 16 process1(weights, values, i + 1, alreadyweight, bag), 17 18 values[i] + process1(weights, values, i + 1, alreadyweight + weights[i], bag)); 19 } 20 21 public static int maxValue2(int[] c, int[] p, int bag) { 22 int[][] dp = new int[c.length + 1][bag + 1]; 23 for (int i = c.length - 1; i >= 0; i--) { 24 for (int j = bag; j >= 0; j--) { 25 dp[i][j] = dp[i + 1][j]; 26 if (j + c[i] <= bag) { 27 dp[i][j] = Math.max(dp[i][j], p[i] + dp[i + 1][j + c[i]]); 28 } 29 } 30 } 31 return dp[0][0]; 32 } 33 34 public static void main(String[] args) { 35 int[] c = { 3, 2, 4, 7 }; 36 int[] p = { 5, 6, 3, 19 }; 37 int bag = 11; 38 System.out.println(maxValue1(c, p, bag)); 39 System.out.println(maxValue2(c, p, bag)); 40 } 41 42 }