组合问题

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]

树形结构：

代码：
使用startIndex控制遍历，每一次递归相当于树形图中的下一层，startIndex相当于递归的深度

class Solution {private List<Integer> path =  new ArrayList<>();private List<List<Integer>> res = new ArrayList<>();public List<List<Integer>> combine(int n, int k) {backTracing(n, k, 1);return res;}public void backTracing(int n, int k, int start) {if (path.size() == k) {res.add(new ArrayList<>(path));return;}// 剪枝，循环的遍历：至多从 n - (k - path.size) + 1 的位置开始搜索for (int i=start; i <= n - (k - path.size()) + 1; i++) {path.add(i);backTracing(n, k, i + 1);  //  i + 1 是因为组合中不能有重复path.removeLast();}}
}

组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1：
输入：candidates = [2,3,6,7], target = 7,
所求解集为： [ [7], [2,2,3] ]

树形结构

代码
因为该题目中，同一个数字可以无限制重复被选取，所以在递归函数调用时与上一题不同，i不需要+1

class Solution {private List<Integer> path = new ArrayList<>();private List<List<Integer>> res = new ArrayList<>();public List<List<Integer>> combinationSum(int[] candidates, int target) {backtracing(candidates, target, 0, 0);return res;}public void backtracing(int[] candidates, int target, int sum, int start) {if (sum > target) return;if (sum == target) {res.add(new ArrayList<>(path));return;}for (int i = start; i < candidates.length; i++) {path.add(candidates[i]);backtracing(candidates, target, sum + candidates[i], i);path.removeLast();  // 回溯，移除路径 path 最后一个元素}}
}

全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

树形结构

代码
排列问题，for循环i从0开始；组合问题是从startIndex开始；使用used数组标注该元素是否使用过

class Solution {private List<Integer> path = new ArrayList<>();private List<List<Integer>> res = new ArrayList<>();private boolean[] used;public List<List<Integer>> permute(int[] nums) {used = new boolean[nums.length];backTracing(nums);return res;}public void backTracing(int[] nums) {if (path.size() == nums.length) {res.add(new ArrayList<>(path));return;}// 排列问题，for循环i从0开始；组合问题是从startIndex开始for(int i = 0; i < nums.length; i++) {// 如果取过了就跳过if (used[i]) {continue;}path.add(nums[i]);used[i] = true;backTracing(nums);used[i] = false;path.removeLast();}}
}

子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

树形结构

代码
因为是子集，只要递归到就可以直接加入结果。之前都是叶节点加入结果集，这一题在递归函数一开始就可以加入结果集。

class Solution {private List<Integer> path = new ArrayList<>();private List<List<Integer>> res = new ArrayList<>();public List<List<Integer>> subsets(int[] nums) {backTracing(nums, 0);return res;}public void backTracing(int[] nums, int startIndex) {res.add(new ArrayList<>(path));if (path.size() == nums.length) {return;}for (int i = startIndex; i < nums.length; i++) {path.add(nums[i]);backTracing(nums, i + 1);path.removeLast(); }}
}

分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
返回 s 所有可能的分割方案。
示例: 输入: “aab” 输出: [ [“aa”,“b”], [“a”,“a”,“b”] ]

树形结构

代码
使用startIndex控制分割位置，[startIndex, i] 就是要截取的子串。
判断这个子串是不是回文，如果是回文，就加入在path中，path用来记录切割过的回文子串。

class Solution {List<List<String>> res = new ArrayList<>();List<String> path = new ArrayList<>();public List<List<String>> partition(String s) {backTracing(s, 0);return res;}public void backTracing(String s, int startIndex) {if (startIndex == s.length()) {res.add(new ArrayList<>(path));return;}StringBuilder sb = new StringBuilder();for (int i = startIndex; i < s.length(); i++) {sb.append(s.charAt(i));if (check(sb)) {path.add(sb.toString());backTracing(s, i + 1);path.removeLast();}}}public boolean check(StringBuilder sb) {for (int i = 0; i < sb.length() / 2; i++) {if (sb.charAt(i) != sb.charAt(sb.length() - 1 - i)) {return false;}}return true;}
}

N皇后

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

树形结构

代码

class Solution {List<List<String>> res = new ArrayList<>();public List<List<String>> solveNQueens(int n) {char[][] board = new char[n][n];for (char[] c : board) {Arrays.fill(c, '.');}backtracing(n, 0, board);return res;}public void backtracing(int n, int row, char[][] board) {if (row == n) {  // 终止条件res.add(array2List(board));return;}for (int col = 0; col < n; col++) {if (isValid(row, col, n, board)) {board[row][col] = 'Q';backtracing(n, row + 1, board);board[row][col] = '.';}}}public boolean isValid(int row, int col, int n, char[][] board) {// 判断列for (int i = 0; i < row; i++) {if (board[i][col] == 'Q') {return false;}}// 判断45° 斜线for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {if (board[i][j] == 'Q') {return false;}}// 判断 135 ° 斜线, 注意 j <= n - 1for (int i = row - 1, j = col + 1; i >= 0 && j <= n - 1; i--, j++) {if (board[i][j] == 'Q') {return false;}}return true;}public List<String> array2List(char[][] board) {List<String> list = new ArrayList<>();for (char[] c : board) {list.add(String.copyValueOf(c));}return list;}
}

电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

树形结构
例如：输入：“23”，抽象为树形结构，如图所示：

代码

class Solution {private List<String> res = new ArrayList<>();private String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};private StringBuilder temp = new StringBuilder();  // 相当于pathpublic List<String> letterCombinations(String digits) {if (digits == null || digits.length() == 0) {return res;}backtracing(digits, 0);return res;}public void backtracing(String digits, int index) {if (index == digits.length()) {  // 叶节点的位置终止res.add(temp.toString());  // StringBuilder 转成String类型return;}String str = numString[digits.charAt(index) - '0'];for(int i=0; i < str.length(); i++) {  temp.append(str.charAt(i));backtracing(digits, index + 1);temp.deleteCharAt(temp.length() - 1);}}
}

单词搜索

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

代码

class Solution {private int[][] directs = new int[][]{{-1,0}, {1,0}, {0,1}, {0,-1}};  // 定义四个方向private int m;  // board 的行数private int n;  // borad 的列数private char[] ws;  // word的字符数组private boolean[][] used; // board中的某元素是否使用过private char[][] boad;  public boolean exist(char[][] board, String word) {this.m = board.length;this.n = board[0].length;this.ws = word.toCharArray();this.used = new boolean[m][n];this.boad = board;for(boolean[] u : used) {Arrays.fill(u, false);}for (int i=0; i<m; i++) {for (int j=0; j < n; j++) {if (boad[i][j] == ws[0]) {used[i][j] = true;if (backtracing(i, j, 1)) {return true;} else {used[i][j] = false;}}}}return false;}public boolean backtracing(int i, int j, int index) {if (index == ws.length) {return true;}for (int[] direct : directs) {int newX = i + direct[0];int newY = j + direct[1];// 超出边界if (!isInArea(newX, newY)) {continue;}// 被使用过if (used[newX][newY]) {continue;}// 不是要找的值if (boad[newX][newY] != ws[index]) {continue;}// 开始递归used[newX][newY] = true;if (backtracing(newX, newY, index + 1)) { // 下一层递归成功return true;} else {used[newX][newY] = false;}}return false;}public boolean isInArea(int i, int j) {if (i >= 0 && i < m && j >= 0 && j < n) {return true;}return false;}
}

括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。
示例 1：
输入：n = 3
输出：[“((()))”,“(()())”,“(())()”,“()(())”,“()()()”]
示例 2：
输入：n = 1
输出：[“()”]

代码
这题不采用和之前一样的代码结构，采用选与不选的方法

class Solution {private int n;private char[] path ;private List<String> ans = new ArrayList<>();public List<String> generateParenthesis(int n) {this.n = n;path = new char[n * 2];dfs(0, 0);return ans;    }// 用选与不选的思路进行递归// i 是第 i 个位置， open是左括号的数量private void dfs(int i, int open) {if (i == 2 * n) {ans.add(new String(path));return;}// 左括号的数量<n ，说明还能继续添加左括号if (open < n) {path[i] = '(';dfs(i + 1, open + 1);  // 下次递归}// 位置 i 时，右括号的位置 < 左括号的位置，说明还能继续添加右括号（如果右括号>左括号就不合法了）if (i - open < open) {path[i] = ')';dfs(i + 1, open);}}
}