学习目标
- 完成回溯法理论基础, 尝试 Hard 级别回溯
学习内容
回溯法理论基础
小结：
回溯算法能解决如下问题：
- 组合问题：N个数里面按一定规则找出k个数的集合
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 棋盘问题：N皇后，解数独等等
回顾模板:
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
for循环横向遍历，递归纵向遍历，回溯不断调整结果集
下面引入 Carl 哥的图片做总结:
332.重新安排行程(Hard)
题目链接:332.重新安排行程
题目：给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。
所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。
例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前。
假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。
示例 1：
输入：tickets = [[“MUC”,“LHR”],[“JFK”,“MUC”],[“SFO”,“SJC”],[“LHR”,“SFO”]]
输出：[“JFK”,“MUC”,“LHR”,“SFO”,“SJC”]
示例 2：
输入：tickets = [[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”] ，但是它字典排序更大更靠后。
提示：
1 <= tickets.length <= 300
tickets[i].length == 2
fromi.length == 3
toi.length == 3
fromi 和 toi 由大写英文字母组成
fromi != toi
思路：无
解决方案：
class Solution {
List<String> ans = new ArrayList<>();
LinkedList<String> path = new LinkedList<>();
boolean[] used;
public List<String> findItinerary(List<List<String>> tickets) {
Collections.sort(tickets, (a,b)->a.get(1).compareTo(b.get(1)));
path.add("JFK");
used = new boolean[tickets.size()];
backTracking(tickets);
return ans;
}
public boolean backTracking(List<List<String>> tickets) {
if(path.size() >= tickets.size() + 1) {
ans = new ArrayList(path);
return true;
}
for(int i = 0; i < tickets.size(); i++) {
if(!used[i] && tickets.get(i).get(0).equals(path.getLast())) {
path.add(tickets.get(i).get(1));
used[i] = true;
if(backTracking(tickets)) return true;
used[i] = false;
path.removeLast();
}
}
return false;
}
}
小结：
Collections.sort(tickets, (a,b)->a.get(1).compareTo(b.get(1)));
用于将 tickets 的数据排序, 即 [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]] 按第二个元素字典序排序, 这是为了符合题解要求的如果存在多种有效的行程，请你按字典排序返回最小的行程组合.
if(!used[i] && tickets.get(i).get(0).equals(path.getLast())
tickets.get(i).get(0)就是[“JFK”,“SFO”]中的"JFK"这个位置的元素, 等于path.getLast()时说明对"JFK"这位置的元素来说有有效路径.
if(backTracking(tickets)) return true;
找到了有效路径就立即停止遍历.
51. N皇后(Hard)
题目链接:51. N皇后
题目：按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
示例 1：
输入：n = 4
输出：[[“.Q…”,“…Q”,“Q…”,“…Q.”],[“…Q.”,“Q…”,“…Q”,“.Q…”]]
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1
输出：[[“Q”]]
提示：
1 <= n <= 9
思路：无
解决方案：
class Solution {
List<List<String>> ans = new ArrayList<>();
public List<List<String>> solveNQueens(int n) {
char[][] chessboard = new char[n][n];
for(char[] c : chessboard) {
Arrays.fill(c, '.');
}
backTracking(0, n, chessboard);
return ans;
}
private void backTracking(int row, int n, char[][] chessboard) {
if(row == n) {
ans.add(Array2List(chessboard));
return;
}
for(int col = 0; col < n; col ++) {
if(isValid(row, col, n, chessboard)) {
chessboard[row][col] = 'Q';
backTracking(row + 1, n, chessboard);
chessboard[row][col] = '.';
}
}
}
private List<String> Array2List(char[][] chessboard) {
List<String> list = new ArrayList();
for(char[] c : chessboard) {
list.add(String.copyValueOf(c));
}
return list;
}
private boolean isValid(int row, int col, int n, char[][] chessboard) {
for(int i = 0; i < row; i++) {
if(chessboard[i][col] == 'Q') return false;
}
for(int i=row-1, j=col-1; i >=0 && j >=0; i--, j--) {
if(chessboard[i][j] == 'Q') return false;
}
for(int i=row-1, j=col+1; i>=0 && j<n; i--, j++) {
if(chessboard[i][j] == 'Q') return false;
}
return true;
}
}
小结：思路跟着题解练习是比较容易理解的, 就是细节需要把握.
Array2List 用来把char[][] chessboard的每行转换为一个String字符串.
isValid 用于校验加入一个新棋子后, 到输入的 row 为止的行内, 是否冲突.
37. 解数独(Hard)
题目链接:37. 解数独
题目：编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
示例 1：
输入：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”]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：
解决方案：
class Solution {
public void solveSudoku(char[][] board) {
solveSudokuHelper(board);
}
public boolean solveSudokuHelper(char[][] board) {
//两个 [0,9) 的 for 循环是为了遍历整个数独格子
for(int i=0; i < 9; i++) {
for(int j = 0; j < 9; j++) {
// 如果有数字, 跳过这个小格
if(board[i][j] != '.') continue;
// 对这个小格填入[1,9], 依次尝试
for(char c = '1'; c <= '9'; c++) {
//尝试判断是否填入后会冲突, 验证不冲突后进入逻辑
if(isValid(i, j, c, board)) {
//填入
board[i][j] = c;
//如果发现答案, 直接返回
if(solveSudokuHelper(board)) return true;
//回溯
board[i][j] = '.';
}
}
// 对这个小格填入 [1,9] 都不成功, 直接返回 false, 证明整个数独无解
return false;
}
}
//提前跳出循环, 证明数独已经结完
return true;
}
public boolean isValid(int row, int col, char c, char[][] board) {
// 验证行是否有重复数字
for(int i = 0; i < 9; i ++) {
if(board[i][col] == c) return false;
}
// 验证列是否有重复数字
for(int i = 0; i < 9; i ++) {
if(board[row][i] == c) return false;
}
// 验证九宫格
int startRow = row / 3 * 3, startCol = col / 3 * 3;
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
if(board[startRow + i][startCol + j] == c) return false;
}
}
return true;
}
}
小结: 是一道思路比较贵的题目, 代码读起来感觉简单, 但思路确实很难想到.
总结
三道题都是思路贵于实践的题目, 有的有其他的更好的思路, 用回溯强解也行, 可以拓宽视野.
315
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
