文章目录
一、回溯算法
1、模板
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
2、可以解决的问题
回溯法，一般可以解决如下几种问题：
组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等
二、 组合问题
1、力扣题目连接
组合问题
组合总和
组合总和II
组合总和III
电话号码字母组合
2、代码
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> combine(int n, int k) {
combineHelper(n, k, 1);
return result;
}
/**
* 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
* @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
*/
private void combineHelper(int n, int k, int startIndex){
//终止条件
if (path.size() == k){
result.add(new ArrayList<>(path));
return;
}
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
path.add(i);
combineHelper(n, k, i + 1);
path.removeLast();
}
}
}
3、优化及注意
1⃣️枝剪操作：
**组合个数：**结果目前的个数path.size，还需要加入的个数k-path.size，当i <= n - (k - path.size()) + 1，就说明就算全部加上后面的数字都不够直接舍弃。
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
**组合总和：**给定的集合排序之后，如果目前的组合中的元素已经达到规定个数或者总和已经超过目标值时，直接舍弃。
if (candidates[j] > target) return;
2⃣️组合求指定和时，可以对数组或者集合进行排序，方便枝剪。
3⃣️给定集合中的数不存在重复元素时，只需要顺序遍历即可（从startIndex开始向后遍历）。但是给定集合存在重复元素时，由于集合问题的结果是不可以存在重复元素的，所以给定集合中的重复元素只允许在层间遍历的时候时需要当作一个元素的，但是在本层遍历的时候是需要当成不同的元素的。比如给定集合为[1,1,1,2]，指定和为3，那么[1,2] 中的1来自与0/1/2都是可以的，但是[1,1,1]就不可以把其当成同一个元素。要去重的是“同一树层上的使用过的”。
解决方法：创建一个boolean数组记录使用情况
used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
used[i - 1] == false，说明同一树层candidates[i - 1]使用过
boolean[] used = new boolean[candidates.length];
// 首先j>0，一是需要用到j-1，另一个是因为j=0时只有1个元素不可能重复
// 给定数组经过排序之后，满足candidates[j] == candidates[j-1]，说明这个数与上一个数相同
// !used[j-1]表示used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。
if (j > 0 && candidates[j] == candidates[j-1] && !used[j-1]) continue;
三、 切割问题
1、力扣题目连接
2、代码
class Solution {
List<List<String>> lists = new ArrayList<>();
Deque<String> deque = new LinkedList<>();
public List<List<String>> partition(String s) {
backTracking(s, 0);
return lists;
}
private void backTracking(String s, int startIndex) {
//如果起始位置大于s的大小，说明找到了一组分割方案
if (startIndex >= s.length()) {
lists.add(new ArrayList(deque));
return;
}
for (int i = startIndex; i < s.length(); i++) {
//如果是回文子串，则记录
if (isPalindrome(s, startIndex, i)) {
String str = s.substring(startIndex, i + 1);
deque.addLast(str);
} else {
continue;
}
//起始位置后移，保证不重复
backTracking(s, i + 1);
deque.removeLast();
}
}
//判断是否是回文串
private boolean isPalindrome(String s, int startIndex, int end) {
for (int i = startIndex, j = end; i < j; i++, j--) {
if (s.charAt(i) != s.charAt(j)) {
return false;
}
}
return true;
}
}
3、优化及注意
1⃣️枝剪操作：可以考虑目前的结果个数是否已经达到要求，如果达到要求就可以直接结束返回。
2⃣️在分割之前，需要先判断是否符合题目的要求，如果不符合就不必添加进path中，所以可以在外面写一个方法专门判断是否符合题目要求。
四、 子集问题
1、力扣题目连接
2、代码
class Solution {
List<List<Integer>> resList = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> subsets(int[] nums) {
subsetsUnit(nums, 0);
return resList;
}
public void subsetsUnit(int[] nums, int start) {
resList.add(new ArrayList<>(path));
if (start == nums.length) return;
for (int i = start; i < nums.length; i++) {
path.add(nums[i]);
subsetsUnit(nums, i+1);
path.removeLast();
}
}
}
3、优化及注意
1⃣️如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！
2⃣️无序问题：子集问题是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！
3⃣️给定数组是否重复：如果给定数组有重复元素，需要先排序，在用一个boolean数组记录是否在本层用过。
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
continue;
}
五、 排列问题
1、力扣题目连接
2、代码
class Solution {
List<List<Integer>> resList2 = new ArrayList<>();
LinkedList<Integer> path2 = new LinkedList<>();
public List<List<Integer>> permute(int[] nums) {
permute(nums,new boolean[nums.length]);
return resList2;
}
public void permute(int[] nums, boolean[] visited) {
if (path2.size() == nums.length) {
resList2.add(new ArrayList<>(path2));
return;
}
for (int i = 0; i < nums.length; i++) {
if (visited[i]) continue;
visited[i] = true;
path2.add(nums[i]);
permute(nums, visited);
path2.removeLast();
visited[i] = false;
}
}
}
3、优化及注意
1⃣️全排列问题：首先排列时有序的[1,2]和[2,1]是不同的，所以每次循环不能从startIndex开始，而是每次都从0开始。因为每次都从0开始，所以要使用一个boolean数组记录某个元素是否已经使用过了，在循环遍历的时候，需要先判断是否使用过了，使用过直接跳过。
2⃣️一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。
3⃣️去重操作：如果给定的元素出现重复元素，那么需要1、对元素进行排序，2、使用boolean数组去重，去重套路还是：
// used[i - 1] == true，说明同一树枝nums[i - 1]使用过
// used[i - 1] == false，说明同一树层nums[i - 1]使用过
// 如果同一树层nums[i - 1]使用过则直接跳过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
六、 棋盘问题
1、力扣题目连接
2、代码
class Solution {
// n皇后问题
char[][] res;
List<List<String>> resList1;
public List<List<String>> solveNQueens(int n) {
res = new char[n][n];
resList1 = new ArrayList<>();
for (char[] arr : res) {
Arrays.fill(arr, '.');
}
solveNQueensUnit(res, 0);
return resList1;
}
public void solveNQueensUnit(char[][] res, int n) {
if (n == res.length) {
List<String> list = new ArrayList<>();
for (int i = 0; i < res.length; i++) {
list.add(new String(res[i]));
}
resList1.add(list);
return;
}
// n表示放置第n行的皇后
// 第n行有（0到len-1）个位置可以放，每个位置都需要判断
for (int j = 0; j < res[n].length; j++) {
if (isValid(res, n, j)) {
res[n][j] = 'Q';
solveNQueensUnit(res, n+1);
res[n][j] = '.';
}
}
}
public boolean isValid(char[][] res, int row, int col) {
// 注意这个验证，因为我们是一行一行第放置皇后，
// 加入放置k行皇后，那么0-k行都已经放好了，k+1到n-1行还没有放
// 我们只需要检查0到k-1行即可，因为k行也是一个一个放。
// 遍历第col列
for (int i = 0; i < row; i++) {
if (res[i][col] == 'Q') return false;
}
// 遍历45度斜线
for (int i = row-1, j = col -1; i >= 0 && j>=0; i--, j--) {
if (res[i][j] == 'Q') return false;
}
// 遍历135度斜线
for (int i = row-1, j = col + 1; i >= 0 && j < res[row].length; i--, j++) {
if (res[i][j] == 'Q') return false;
}
return true;
}
}
class Solution {
public void solveSudoku(char[][] board) {
solveSudokuHelper(board);
}
private boolean solveSudokuHelper(char[][] board){
//「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
// 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」
for (int i = 0; i < 9; i++){ // 遍历行
for (int j = 0; j < 9; j++){ // 遍历列
if (board[i][j] != '.'){ // 跳过原始数字
continue;
}
for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适
if (isValidSudoku(i, j, k, board)){
board[i][j] = k;
if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
return true;
}
board[i][j] = '.';
}
}
// 9个数都试完了，都不行，那么就返回false
return false;
// 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
// 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」
}
}
// 遍历完没有返回false，说明找到了合适棋盘位置了
return true;
}
/**
* 判断棋盘是否合法有如下三个维度:
* 同行是否重复
* 同列是否重复
* 9宫格里是否重复
*/
private boolean isValidSudoku(int row, int col, char val, char[][] board){
// 同行是否重复
for (int i = 0; i < 9; i++){
if (board[row][i] == val){
return false;
}
}
// 同列是否重复
for (int j = 0; j < 9; j++){
if (board[j][col] == val){
return false;
}
}
// 9宫格里是否重复
int startRow = (row / 3) * 3;
int startCol = (col / 3) * 3;
for (int i = startRow; i < startRow + 3; i++){
for (int j = startCol; j < startCol + 3; j++){
if (board[i][j] == val){
return false;
}
}
}
return true;
}
}
3、优化及注意
1⃣️返回值：因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。
七、回溯算法总结
回溯算法一般可以解决：
组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等
1、如果把把回溯问题看成一颗树：
1⃣️其中组合问题、分割问题和排列问题是收集叶子结点，只需要path路径中的元素个数/总和/分割数量等达到要求，就可以将path存入到结果集中返回。
2⃣️子集问题是收集树到所有节点，所以不需要判断path中的元素是否达到要求，每一个path都要加到结果集中。
3⃣️棋盘问题是收集某一条路径（如果不需要求结果的数量多话），所以需要对回溯的返回值做要求，选择boolean，如果找到满足要求的即可直接返回true，如果发现不满足要求就直接返回false，在回溯的时候可以直接进行判断。
2、给定集合是否有重复元素：
1⃣️无序问题，例如组合问题等，如果没有重复元素，那么每次循环都需要从start开始即可。
有序问题，例如排列问题，如果没有重复元素，需要对元素集合进行排序，每次循环遍历都需要从0开始，借助boolean数组进行标记使用过与否。
2⃣️有重复元素，需要对元素进行排序，然后借助boolean类型进行标记是否使用过与否。
// used[i - 1] == true，说明同一树枝nums[i - 1]使用过
// used[i - 1] == false，说明同一树层nums[i - 1]使用过
// 如果同一树层nums[i - 1]使用过则直接跳过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
3、枝剪与去重：
1⃣️枝剪操作：是由于确定不满足题目要求直接返回，比如剩余的个数不足以满足题目要求的个数，即使是全都加入也不够，那么我们可以确定这个path不符合要求，直接舍去即可。通过条件判断进行枝剪。
2⃣️去重操作：与枝剪不同，去重是因为存在重复的元素，在同一数层上不可以再重复使用，比如[1,1,2]，的组合[1,2]中的1来着两个1都是可以的，只能算1个。通过boolean数组进行判断。
4、加入判断：
在分割回文串或者N皇后这种问题，在进行添加到path之前，需要先进行判断，如果符合要求再进行添加，不符合要求就直接跳过即可。
7958
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
