范范 2020-01-25
1, 把问题转化为规模缩小了的同类问题的子问题
2, 有明确的不需要继续进行递归的条件(base case)
3, 有当得到了子问题的结果之后的决策过程
4, 不记录每一个子问题的解
一定要学会怎么去尝试,因为这是动态规划的基础,这一内容我们将在提升班讲述
打印n层汉诺塔从最左边移动到最右边的全部过程
public static void hanoi(int n) { if (n > 0) { func(n, "左", "右", "中"); } } // 1~i 圆盘 目标是from -> to, other是另外一个 public static void func(int N, String from, String to, String other) { if (N == 1) { // base System.out.println("Move 1 from " + from + " to " + to); } else { func(N - 1, from, other, to); System.out.println("Move " + N + " from " + from + " to " + to); func(N - 1, other, to, from); } }
public static List<String> getAllSubs(String s){ char[] str = s.toCharArray(); String path = ""; List<String> ans = new ArrayList<>(); process(str, 0, ans, path); return ans; } public static void process(char[] str, int index, List<String> ans, String path) { if(index == str.length) { ans.add(path); return; } String noPath = path; process(str, index+1,ans, noPath); String yesPath = path + String.valueOf(str[index]); process(str, index+1,ans, yesPath); }
省空间方法用str
public static void printAllSubsquence(String str) { char[] chs = str.toCharArray(); process(chs, 0); } // 当前来到i位置,要和不要,走两条路 // 之前的选择,所形成的结果,是str public static void process(char[] str, int i) { if (i == str.length) { System.out.println(String.valueOf(str)); return; } process(str, i + 1); // 要当前字符的路 char tmp = str[i]; str[i] = 0; process(str, i + 1); // 不要当前字符的路 str[i] = tmp; }
打印一个字符串的全部排列,要求不要出现重复的排列
public static ArrayList<String> Permutation(String str) { ArrayList<String> res = new ArrayList<>(); if (str == null || str.length() == 0) { return res; } char[] chs = str.toCharArray(); process(chs, 0, res); return res; } // str[i..]范围上,所有的字符,都可以在i位置上,后续都去尝试 // str[0..i-1]范围上,是之前做的选择 // 请把所有的字符串形成的全排列,加入到res里去 public static void process(char[] str, int i, ArrayList<String> res) { if (i == str.length) { res.add(String.valueOf(str)); } boolean[] visit = new boolean[26]; // visit[0 1 .. 25] for (int j = i; j < str.length; j++) { if (!visit[str[j] - 'a']) { visit[str[j] - 'a'] = true; //去重 swap(str, i, j); process(str, i + 1, res); swap(str, i, j); } } } public static void swap(char[] chs, int i, int j) { char tmp = chs[i]; chs[i] = chs[j]; chs[j] = tmp; } public static List<String> getAllC(String s) { List<String> ans = new ArrayList<>(); ArrayList<Character> set = new ArrayList<>(); for (char cha : s.toCharArray()) { set.add(cha); } process(set, "", ans); return ans; } public static void process(ArrayList<Character> list, String path, List<String> ans) { if (list.isEmpty()) { ans.add(path); return; } HashSet<Character> picks = new HashSet<>(); for (int index = 0; index < list.size(); index++) { if (!picks.contains(list.get(index))) { picks.add(list.get(index)); String pick = path + list.get(index); ArrayList<Character> next = new ArrayList<>(list); next.remove(index); process(next, pick, ans); } } }
不能申请额外的数据结构,只能使用递归函数。 如何实现?
import java.util.Stack; public class ReverseStackUsingRecursive { public static void reverse(Stack<Integer> stack) { if (stack.isEmpty()) { return; } int i = f(stack); reverse(stack); stack.push(i); } public static int f(Stack<Integer> stack) { int result = stack.pop(); if (stack.isEmpty()) { return result; } else { int last = f(stack); stack.push(result); return last; } } public static void main(String[] args) { Stack<Integer> test = new Stack<Integer>(); test.push(1); test.push(2); test.push(3); test.push(4); test.push(5); reverse(test); while (!test.isEmpty()) { System.out.println(test.pop()); } } }
那么一个数字字符串比如"111",就可以转化为"AAA"、"KA”和"AK”。 给定一个只有数字字符组成的字符串str,返回有多少种转化结果。
public static int number(String str) { if (str == null || str.length() == 0) { return 0; } return process(str.toCharArray(), 0); } // i之前的位置,如何转化已经做过决定了, 不用再关心 // i... 有多少种转化的结果 public static int process(char[] str, int i) { if (i == str.length) { // base case return 1; } // i没有到终止位置 if (str[i] == '0') { return 0; } // str[i]字符不是‘0’ if (str[i] == '1') { int res = process(str, i + 1); // i自己作为单独的部分,后续有多少种方法 if (i + 1 < str.length) { res += process(str, i + 2); // (i和i+1)作为单独的部分,后续有多少种方法 } return res; } if (str[i] == '2') { int res = process(str, i + 1); // i自己作为单独的部分,后续有多少种方法 // (i和i+1)作为单独的部分并且没有超过26,后续有多少种方法 if (i + 1 < str.length && (str[i + 1] >= '0' && str[i + 1] <= '6')) { res += process(str, i + 2); // (i和i+1)作为单独的部分,后续有多少种方法 } return res; } // str[i] == '3' ~ '9' return process(str, i + 1); } public static int dpWays(String s) { if (s == null || s.length() == 0) { return 0; } char[] str = s.toCharArray(); int N = str.length; int[] dp = new int[N + 1]; dp[N] = 1; for (int i = N - 1; i >= 0; i--) { if (str[i] == '0') { dp[i] = 0; } else if (str[i] == '1') { dp[i] = dp[i + 1]; if (i + 1 < N) { dp[i] += dp[i + 2]; } } else if (str[i] == '2') { dp[i] = dp[i + 1]; if (i + 1 < str.length && (str[i + 1] >= '0' && str[i + 1] <= '6')) { dp[i] += dp[i + 2]; } } else { dp[i] = dp[i + 1]; } } return dp[0]; }
weights和values, weights [i]和values [ i]分别代表 i号物品的重量和价值。给定一个正数bag,表示一个载重bag的袋子,你装的物 品不能超过这个重量。返回你能装下最多的价值是多少?
public static int getMaxValue(int[] w, int[] v, int bag) { return process(w, v, 0, 0, bag); } // index... 最大价值 public static int process(int[] w, int[] v, int index, int alreadyW, int bag) { if (alreadyW > bag) { return -1; } // 重量没超 if (index == w.length) { return 0; } int p1 = process(w, v, index + 1, alreadyW, bag); int p2next = process(w, v, index + 1, alreadyW + w[index], bag); int p2 = -1; if (p2next != -1) { p2 = v[index] + p2next; } return Math.max(p1, p2); } public static int maxValue(int[] w, int[] v, int bag) { return process(w, v, 0, bag); } // 只剩下rest的空间了, // index...货物自由选择,但是不要超过rest的空间 // 返回能够获得的最大价值 public static int process(int[] w, int[] v, int index, int rest) { if (rest <= 0) { // base case 1 return 0; } // rest >=0 if (index == w.length) { // base case 2 return 0; } // 有货也有空间 int p1 = process(w, v, index + 1, rest); int p2 = Integer.MIN_VALUE; if (rest >= w[index]) { p2 = v[index] + process(w, v, index + 1, rest - w[index]); } return Math.max(p1, p2); } public static int dpWay(int[] w, int[] v, int bag) { int N = w.length; int[][] dp = new int[N + 1][bag + 1]; for (int index = N - 1; index >= 0; index--) { for (int rest = 1; rest <= bag; rest++) { dp[index][rest] = dp[index + 1][rest]; if (rest >= w[index]) { dp[index][rest] = Math.max(dp[index][rest], v[index] + dp[index + 1][rest - w[index]]); } } } return dp[0][bag]; }
玩家A和玩家B依次拿走每张纸 牌,规定玩家A先拿,玩家B后拿,但是每个玩家每次只能拿走最左或最右的纸牌,玩家A 和玩家B都绝顶聪明。请返回最后获胜者的分数。
【举例】arr=[1,2, 100, 4]。开始时,玩家A只能拿走1或4。如果开始时玩家A拿走1,则排列变为[2,100,4],接下来 玩家B可以拿走2或4,然后继续轮到玩家A...
如果开始时玩家A拿走4,则排列变为[1,2,100],接下来玩家B可以拿走1或100,然后继 续轮到玩家A...
玩家A作为绝顶聪明的人不会先拿4,因为拿4之后,玩家B将拿走100。所以玩家A会先拿1, 让排列变为[2,100,4],接下来玩家B不管怎么选,100都会被玩家A拿走。玩家A会获胜, 分数为101。所以返回101。arr=[1, 100, 2]。
开始时,玩家A不管拿1还是2,玩家B作为绝顶聪明的人,都会把100拿走。玩家B会获胜, 分数为100。所以返回100。
public static int win1(int[] arr) { if (arr == null || arr.length == 0) { return 0; } return Math.max(f(arr, 0, arr.length - 1), s(arr, 0, arr.length - 1)); } public static int f(int[] arr, int i, int j) { if (i == j) { return arr[i]; } return Math.max(arr[i] + s(arr, i + 1, j), arr[j] + s(arr, i, j - 1)); } public static int s(int[] arr, int i, int j) { if (i == j) { return 0; } return Math.min(f(arr, i + 1, j), f(arr, i, j - 1)); } public static int win2(int[] arr) { if (arr == null || arr.length == 0) { return 0; } int[][] f = new int[arr.length][arr.length]; int[][] s = new int[arr.length][arr.length]; for (int j = 0; j < arr.length; j++) { f[j][j] = arr[j]; for (int i = j - 1; i >= 0; i--) { f[i][j] = Math.max(arr[i] + s[i + 1][j], arr[j] + s[i][j - 1]); s[i][j] = Math.min(f[i + 1][j], f[i][j - 1]); } } return Math.max(f[0][arr.length - 1], s[0][arr.length - 1]); }
是指在N*N的棋盘上要摆N个皇后,要求任何两个皇后不同行、不同列, 也不在同一条斜线上。
给定一个整数n,返回n皇后的摆法有多少种。
n=1,返回1。n=2或3, 2皇后和3皇后问题无论怎么摆都不行,返回0。n=8,返回92。
public static int num1(int n) { if (n < 1) { return 0; } int[] record = new int[n];// record[0..i-1]表示之前的行,放了的皇后位置 return process1(0, record, n); } // 目前来到了第i行 public static int process1(int i, int[] record, int n) {// n代表整体一共有多少行 if (i == n) { //终止行 return 1; } int res = 0; for (int j = 0; j < n; j++) {// 当前i行的皇后,放在j列 if (isValid(record, i, j)) { //判断是否有效 record[i] = j; res += process1(i + 1, record, n); } } return res; // 返回值是,摆完所有的皇后,合理的摆法有多少种 } public static boolean isValid(int[] record, int i, int j) { for (int k = 0; k < i; k++) { //之前的某个k行的皇后 if (j == record[k] || Math.abs(record[k] - j) == Math.abs(i - k)) { return false; } } return true; }
位运算方法
public static int num2(int n) { if (n < 1 || n > 32) { return 0; } int upperLim = n == 32 ? -1 : (1 << n) - 1; return process2(upperLim, 0, 0, 0); } public static int process2(int upperLim, int colLim, int leftDiaLim, int rightDiaLim) { if (colLim == upperLim) { return 1; } int pos = 0; int mostRightOne = 0; // 所有候选皇后的位置,都在pos上 pos = upperLim & (~(colLim | leftDiaLim | rightDiaLim)); int res = 0; while (pos != 0) { mostRightOne = pos & (~pos + 1); pos = pos - mostRightOne; res += process2(upperLim, colLim | mostRightOne, (leftDiaLim | mostRightOne) << 1, (rightDiaLim | mostRightOne) >>> 1); } return res; }