回溯算法总结：
实质：
回溯算法本质是一种暴力算法，通过递归穷举数组的结点，通过处理各种结点，返回想要的结果。由于利用递归，故回溯算法的处理情况可以理解成一颗N叉树，通过剪枝，取得想要的叶子结点(结果)。
ps : 以[1,2,3]为例:
...表示在单层逻辑中，不同的递归处理可能产生不同的结点。
应用场景：
子集问题：求出数组的子集(包含空集和本身) 需要处理2^n个叶子结点
组合问题：求出数组中元素的组合符合某某条件
排列问题：求出数组中元素的全排列组合
切割问题：求出一个字符串有多少种符合要求的切割方法
棋盘问题：N皇后、解数独
回溯三部曲：
函数终止条件：
if(条件){
结果录入
return;
}参数以及返回值:
public void backtracking(int[] nums,int startIndex,int[] used);单层逻辑:
for(int i = ? ;i < nums.length;i++){
if(条件){
临时结果集录入
backtracking(nums,i + 1) //递归
回溯
}
//if条件可以当做提前剪枝操作
}剪枝操作一般在for循环中体现。
常见问题以及做法：
①、子集以及组合问题：
子集和组合无序，故一般需要一个startIndex作为参数，提供遍历索引，遍历数组的后序内容，根据题目要求进行剪枝操作，对叶子结点进行判断。
②、全排列问题：
与子集问题不同，全排列要求所有结果(叶子结点)包括数组中的所有值，且与元素序列有关，故每次单层逻辑 i 需要从0开始，从头遍历处理数组中的所有元素，此时，需要一个used数组，标记当前结点是否已经使用过当前下标的值，避免结果集重复。
③、切割问题：
切割问题的处理跟子集类似，子集问题处理的结点是由数组中的一个个元素组成的，而切割问题则以 index 的值为左区间、i 的值为右区间切割字符串，然后处理一个个子字符串，最终返回符合题意的结果。
④、棋盘问题：
N皇后、解数独使用回溯算法处理感觉跟深度搜索类似，就是套用一到两层for循环定位到待处理的结点，然后穷举所有情况，若递归完所有结点，则表示一种符合题目要求的情况，若不符合，则回溯，重新递归新的情况。
去重操作：
回溯算法的去重操作一般有两种：借助set反射或借助used数组标记
这两种做法都是对树的横向遍历上判断是否重复，对重复的结点进行纵向剪枝。
used数组：单层逻辑中对数组元素的处理顺序是从左往右的，若当前数的左边出现相等的数，且used标记当前结点不包括它，则说明前面相等的数已经处理完了，当前数的所有情况都包含于前面的数，需要去重。 used数组需要元素有序，便于去重操作。且used需要回溯操作。
set：set的去重逻辑跟used一样，只是判断条件换成是否contains当前数，set没有作为参数参与递归过程，故递归过程会创建大量的set作为辅助，set不需要回溯。
棋盘题目：
①、重新安排行程
给你一份航线列表
tickets，其中tickets[i] = [fromi, toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从
JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。
- 例如，行程
["JFK", "LGA"]与["JFK", "LGB"]相比就更小，排序更靠前。假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。
事例：
输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]] 输出：["JFK","MUC","LHR","SFO","SJC"]
代码：
public List<String> findItinerary(List<List<String>> tickets) {
//排序 根据票的终点排 获得最小的航程组合
Collections.sort(tickets,(a,b) -> a.get(1).compareTo(b.get(1)));
boolean[] used = new boolean[tickets.size()];
//添加起点
tmp.add("JFK");
backtracking((ArrayList)tickets,used);
return res;
}
List<String> res;
LinkedList<String> tmp = new LinkedList<>();
public boolean backtracking(ArrayList<List<String>> tickets,boolean[] used){
if(tmp.size() == tickets.size() + 1){
res = new ArrayList<>(tmp);
return true;
}
//单层循环
for(int i = 0;i < tickets.size();i++){
if(!used[i] && tickets.get(i).get(0).equals(tmp.getLast())){
// !used[i] 代表当前票还没用 后面表示当前票的出发点对应航程的终点，两条件都满足即可触发
tmp.add(tickets.get(i).get(1));
used[i] = true;
//递归
if(backtracking(tickets,used)){
//能进来表示已经完成 res也添加成功
return true;
}
//回溯
tmp.removeLast();
used[i] = false;
}
}
return false;
} ②、N皇后
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将
n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数
n，返回所有不同的 n 皇后问题 的解决方案。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中
'Q'和'.'分别代表了皇后和空位。
事例：
输入：n = 4 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]] 解释：如上图所示，4 皇后问题存在两个不同的解法。
代码：
public List<List<String>> solveNQueens(int n) {
char[][] board = new char[n][n];
for(char[] rowBoard : board){
Arrays.fill(rowBoard,'.');
}
backtracking(board,0);
return res;
}
public List<List<String>> res = new ArrayList<>();
public void backtracking(char[][] board,int row){
if(row == board.length){
//添加棋盘
List<String> tmp = new ArrayList<>();
for(char[] rowBoard : board){
tmp.add(String.copyValueOf(rowBoard));
}
res.add(tmp);
}
//单层逻辑
for(int i = 0;i < board[0].length;i++){
if(isValid(board,i,row)){
//符合逻辑 添加皇后
board[row][i] = 'Q';
//递归
backtracking(board,row + 1);
//回溯
board[row][i] = '.';
}
}
}
public boolean isValid(char[][] board,int col,int row){
//判断位置是否合法
//判断列
for(int i = 0;i < row;i++){
if(board[i][col] == 'Q'){
return false;
}
}
//判断左上斜对角线
for(int i = row - 1,j = col - 1;i >= 0 && j >= 0;i--,j--){
if(board[i][j] == 'Q'){
return false;
}
}
//判断右上斜对角线
for(int i = row - 1,j = col + 1;i >= 0 && j <= board[0].length - 1;i--,j++){
if(board[i][j] == 'Q'){
return false;
}
}
return true;
}③、解数独
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
- 数字
1-9在每一行只能出现一次。- 数字
1-9在每一列只能出现一次。- 数字
1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图）数独部分空格内已填入了数字，空白格用
'.'表示。
事例：
输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]] 输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]] 解释：输入的数独如上图所示，唯一有效的解决方案如下所示：
代码：
public void solveSudoku(char[][] board) {
backtracking(board);
}
public boolean backtracking(char[][] board){
//单层逻辑
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++){
//遍历能填充的点
if(isValid(board,i,j,k)){
//可以填
board[i][j] = k;
//递归
if(backtracking(board)){
return true;
}
//回溯
board[i][j] = '.';
}
}
//没能找到能填充的数 棋盘错误
return false;
}
}
//遍历完整个棋盘 没遇到'.' 说明填充完毕
return true;
}
public boolean isValid(char[][] board,int row,int col,char k){
//判断当前数填入是否合法
//判断列
for(int i = 0;i < 9;i++){
if(board[i][col] == k){
return false;
}
}
//判断行
for(int i = 0;i < 9;i++){
if(board[row][i] == k){
return false;
}
}
//判断3 * 3宫格
int rowBoardStart = (row / 3) * 3;
int colBoardStart = (col / 3) * 3;
for(int i = rowBoardStart;i < rowBoardStart + 3;i++){
for(int j = colBoardStart;j < colBoardStart + 3;j++){
if(board[i][j] == k){
return false;
}
}
}
return true;
}
94
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
