数据结构与算法——暴力递归

暴力递归就是尝试

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());
		}
	}
}

规定1和A对应、2和B对应、3和C对应...

那么一个数字字符串比如"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];
	}

给定两个长度都为N的数组

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];
	}

给定一个整型数组arr,代表数值不同的纸牌排成一条线。

玩家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皇后的摆法有多少种。

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;
	}