Leetcoder Day26｜回溯part06：总结+三道hard题

332.重新安排行程

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

提示：

如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前

所有的机场都用三个大写字母表示（机场代码）。

假定所有机票至少存在一种合理的行程。

所有的机票必须都用一次且只能用一次。

示例 1：

输入：[["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]

输出：["JFK", "MUC", "LHR", "SFO", "SJC"]

示例 2：

输入：[["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]

输出：["JFK","ATL","JFK","SFO","ATL","SFO"]

解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"]。但是它自然排序更大更靠后。

这道题目有几个难点：

一个行程中，如果航班处理不好容易变成一个圈，成为死循环
有多种解法，字母序靠前排在前面，让很多同学望而退步，如何该记录映射关系呢？
使用回溯法（也可以说深搜）的话，那么终止条件是什么呢？
搜索的过程中，如何遍历一个机场所对应的所有机场。

下面是一个有重复机场的例子出发机场和到达机场也会重复的，如果在解题的过程中没有对集合元素处理好，就会死循环。

对于记录映射关系，可以用哈希集合。在这个过程中，需要可以增删元素。因为出发机场和到达机场是会重复的，搜索的过程没及时删除目的机场就会死循环。

按照回溯三部曲：

递归函数参数：要有机票数ticketNum，还要判断机票是否使用过，所以加一个bool数组used，注意，这里函数的返回值用的是bool， 因为我们只需要找到一个行程，就是在树形结构中唯一的一条通向叶子节点的路线。之前在二叉树部分有总结过：
- 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。
- 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值
- 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值。

递归终止条件：本题的终止条件可以这样考虑，如[["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]，有四张机票，5个机场，那么行程里的机场个数是5就可以了，也就是path里机场个数等于ticketNum+1
单层搜索的逻辑：如果这张机票没有被使用过，且当前机票的第一个机场，等于path里的最后一个机场，就可以将其添加进path。

java 复制代码

class Solution {
    LinkedList<String> res;
    LinkedList<String> path=new LinkedList<>();
    public boolean backTracking(List<List<String>> tickets, boolean[] used){
        if(path.size()==tickets.size()+1){
            res=new LinkedList(path);
            return true;
        }
        for(int i=0;i<tickets.size();i++){
            if(!used[i] && tickets.get(i).get(0).equals(path.getLast())){
                used[i]=true;
                path.add(tickets.get(i).get(1));
                if(backTracking(tickets, used)){
                    return true;
                }
                used[i]=false;
                path.removeLast();
            }
        }
        return false;
    }
    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()];
        path.add("JFK");
        backTracking(tickets, used);
        return res;

    }
}

现在leetcode里这个方法已经超时了。

51. N皇后

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：
复制代码
输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如图所示，4 皇后问题存在两个不同的解法。

n皇后问题是回溯算法解决的经典问题，首先来看一下皇后们的约束条件：

不能同行
不能同列
不能同斜线

确定完约束条件，来看看究竟要怎么去搜索皇后们的位置，其实搜索皇后的位置，可以抽象为一棵树。

下面用一个 3 * 3 的棋盘，将搜索过程抽象为一棵树，如图：

从图中，可以看出，二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。用皇后们的约束条件，来回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

递归函数参数：依然定义全局变量二维数组result来记录最终结果。参数n是棋盘的大小，然后用row来记录当前遍历到棋盘的第几层。
终止条件：递归到棋盘最底层（也就是叶子节点）的时候，就可以收集结果并返回

单层搜索的逻辑：递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。每次都是要从新的一行的起始位置开始搜，所以都是从0开始。这里面还涉及验证当前位置是否合法的方法，需要按照约束条件进行去重。这里不需要检查行是否重复，因为在单层搜索的过程中，每一层递归，只会选同一行里的一个元素，所以不用去重了。

在N皇后问题中，我们通常只考虑两个对角线方向：从左上角到右下角的45度对角线和从右上角到左下角的135度对角线。

这里还要注意⚠️，在将当前度棋盘结果添加到res中时，要将chessboard转换为List：res.add(Array2List(chessboard)); 因为原先的chessboard为二维数组：

java 复制代码

public List Array2List(char[][] chessboard) {
        List<String> list = new ArrayList<>();

        for (char[] c : chessboard) {
            list.add(String.copyValueOf(c));
        }
        return list;
    }

java 复制代码

class Solution {
    List<List<String>> res =new ArrayList<>();
    public List ArraytoList(char[][] chessboard){
        List<String> list = new ArrayList<>();
        for(char[] c:chessboard){
            list.add(String.copyValueOf(c));
        }
        return list;
    }
    
    public boolean isValid(int row, int col, int n, char[][] chessboard){
        //检查列
        for(int i=0;i<row;i++){
            if(chessboard[i][col]=='Q'){
                return false;
            }
        }
        //检查45度斜线
        for(int i=row-1, j=col-1;i>=0 && j>=0; i--, j--){
            if(chessboard[i][j]=='Q'){
                return false;
            }
        }
        //检查135度斜线
        for(int i=row-1, j=col+1; i>=0 && j<n;i--,j++){
            if(chessboard[i][j]=='Q'){
                return false;
            }
        }
        return true;
    }
    public void backTracking(int n, int row, char[][] chessboard){
        if(row==n){
            res.add(ArraytoList(chessboard));
            return;
        }
        for(int col=0;col<n;col++){
            if(isValid(row, col, n, chessboard)){
                chessboard[row][col]='Q';
                backTracking(n, row+1, chessboard);
                chessboard[row][col]='.';
            }

        }
    }
    public List<List<String>> solveNQueens(int n) {
        char[][] chessboard=new char[n][n];
        for(char[]c:chessboard){
            Arrays.fill(c,'.');
        }
        backTracking(n,0,chessboard);
        return res;
    }
}

总结

回溯部分涉及到的题型比较多，而且在二叉树环节也用到了回溯。回溯的问题都可以抽象为树结构，并且其本质是递归，也就是，**只要有递归就会有回溯！**这次刷题从代码随想录里学到了很有用的回溯模板，但是也不能只依赖于套模板，要具体问题具体分析。

回溯算法能解决如下问题：

组合问题：N个数里面按一定规则找出k个数的集合
排列问题：N个数按一定规则全排列，有几种排列方式
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
棋盘问题：N皇后，解数独等等

回溯的模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

组合问题

**for循环横向遍历，递归纵向遍历，回溯不断调整结果集，因为取过的元素不再重复取，所以需要startIdx。**如果是一个集合来求组合的话，就需要startIndex，如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，比如电话号码组合问题。

优化回溯算法只有剪枝一种方法，思路就是如果剩下的元素个数已经不满足需要的元素，就停止搜索。

（1）如果有元素总和的限制，剪枝的思路就是已选元素总和如果已经大于n（题中要求的和）了，那么往后遍历就没有意义了，直接剪掉

（2）如果包含重复数值的元素，那么使用过的就不能再次使用，carl哥用树枝重复和树层重复来进行细分。可以通过创建一个used数组来记录，也可以使用startIdx来进行去重，先对数组进行排序，如果candidates[i] == candidates[i - 1]相同的情况下：

used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
used[i - 1] == false，说明同一树层candidates[i - 1]使用过

（3）多个集合来求组合，就不需要startIdx，而是从0开始遍历。

切割问题

切割问题有如下几个难点：

切割问题其实类似组合问题
如何模拟那些切割线
切割问题中递归如何终止
在递归循环中如何截取子串
如何判断回文

如果想到了用求解组合问题的思路来解决切割问题本题就成功一大半了 ，接下来就可以对着模板照葫芦画瓢。但后序如何模拟切割线，如何终止，如何截取子串，其实都不好想，最后判断回文算是最简单的了。

所以本题应该是一个道hard题目了。除了这些难点，本题还有细节，例如：切割过的地方不能重复切割所以递归函数需要传入i + 1。

树形结构如下：

子集问题

要记住，在树形结构中子集问题是要收集所有节点的结果，而组合问题是收集叶子节点的结果。

子集问题一般都会先进行排序，注意：result.push_back(path);要放在终止条件的上面，如下：

result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉结果
if (startIndex >= nums.size()) { // 终止条件可以不加
    return;
}

在求递增子序列的时候一定注意，不可以进行排序。所以可以借助哈希集合，记录当前元素是否被使用过。

排列问题

排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方。

可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。

每层都是从0开始搜索而不是startIndex
需要used数组记录path里都放了哪些元素

Leetcoder Day26｜ 回溯part06：总结+三道hard题

332.重新安排行程

51. N皇后

总结

组合问题

切割问题

子集问题

排列问题

Leetcoder Day26｜回溯part06：总结+三道hard题