Day30｜回溯算法part06：332.重新安排行程、51. N皇后、37. 解数独、总结

332. 重新安排行程（弄清题意和思路）

leetcode链接：力扣题目链接(opens new window)

给你一份航线列表 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"] ，但是它字典排序更大更靠后。

这道题的难度是 Hard，一刷弄清题意和思路。本质上就是给了一张图，要求输出一条路径经过图中的所有边 （不是点，点是可以重复的），并且每个边只能经过一次。

如何判断死循环

比如下面的例子：

可以看出出发机场和到达机场也会重复的，这个就是我说的遍历的是边（回溯）而不是点（BFS）的问题。

如何记录字典序

使用一个嵌套的multiset进行图的映射：

unordered_map<string, map<string, int>> targets;

相当于
unordered_map<出发机场, map<到达机场, 航班次数>> targets;

这里不考虑使用：

unordered_map<string, multiset> targets;

unordered_map<出发机场, 到达机场的集合> targets

因为遍历multiset的时候，不能删除元素，一旦删除元素，迭代器就失效了。所以用一个map结构记录（不删）航班还可以经过的次数，如果“航班次数”大于零，说明目的地还可以飞，如果“航班次数”等于零说明目的地不能飞了，而不用对集合做删除元素或者增加元素的操作。

回溯三部曲

1. 确定回溯函数参数和返回值

因为这里只需要找到一条到叶子结点的路径，收集到的结果等于票的个数就返回，只需要一条就可以了，所以返回值使用bool，刚才的unordered_map作为全局变量映射状态。ticketNum作为终止条件，在初始化unordered_map的时候记录。

unordered_map<string, map<string, int>> targets;
bool backtracking(int ticketNum, vector<string>& result) {

其中map在主函数里面初始化：

for(auto ticket: tickets){
            targets[ticket[0]][ticket[1]]++;
        }
        result.push_back("JFK");

2. 确定终止条件：

 if(result.size() == ticketNum + 1){
            return true;
        }

如果result的大小和票数+1一样说明找到了一条路径（+1是因为最开始把JFK塞进去了）

3. 确定单层回溯搜索

遍历targets，如果票还有就加入路径，没有就不加入

for (auto& target : targets[result.back()]){
            if(target.second > 0)//还没飞完
            {
                result.push_back(target.first);
                target.second--;
                if(backtracing(ticketNum, result)){
                    return true;
                }
                result.pop_back();
                target.second++;

            }

这里注意auto后面一定要加&，表示引用运算符，负责循环里改变targets的操作是不生效的。

总代码：

class Solution {
private:
    unordered_map<string,map<string,int>> targets;
    bool backtracing(int ticketNum, vector<string>& result) {
        if(result.size() == ticketNum + 1){
            return true;
        }
        for (auto& target : targets[result.back()]){
            if(target.second > 0)//还没飞完
            {
                result.push_back(target.first);
                target.second--;
                if(backtracing(ticketNum, result)){
                    return true;
                }
                result.pop_back();
                target.second++;

            }
        }
        return false;
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> result;
        for(auto ticket: tickets){
            targets[ticket[0]][ticket[1]]++;
        }
        result.push_back("JFK");
        backtracing(tickets.size(), result);
        return result;
    }
};

51. N皇后

leetcode链接：51. N 皇后

视频链接：这就是传说中的N皇后？ 回溯算法安排！| LeetCode：51.N皇后

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

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

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

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

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

输入：n = 1
输出：[["Q"]]

是一道经典的题目，本来学数据结构的时候就学过。当时用的是BFS的思想。跟之前的合法IP地址一样，但是是二维数组，没想到怎么搜索。拆分成下面两个子问题。

• 如何回溯
• 如何判断放的是否合法

如何回溯

搜索过程可以抽象成下面的树：其中二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。

1. 确定回溯函数参数和返回值

vector<vector<string>> result;
vector<string> path;
void backtracing(vector<string>& chessboard, int n, int row){//chessboard是我们要画的棋盘

2. 确定终止条件

if(row == n){
  result.push_back(chessboard);
  return;
}

3. 确定单层搜索过程

for(int i = 0;i < n ;i++){
            if(isValid(row, i, chessboard, n)){
                chessboard[row][i] = 'Q';
                backtracing(n, row + 1, chessboard);
                chessboard[row][i] = '.';
            }
        }

放皇后的规则

• 同一行不能放
• 同一列不能放
• 每一个皇后的左上右上左下右下不能放

最终的代码：

bool isValid(int row, int col, vector<string>& chessboard, int n) {
        // 检查列
        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;
    }

最终代码：

class Solution {
private:
    vector<vector<string>> result;
    bool isValid(int row, int col, vector<string>& chessboard, int n) {
        // 检查列
        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;
    }

    void backtracing(int n, int row, vector<string> chessboard){
        if(row == n){
            result.push_back(chessboard);
            return;
        }
        for(int i = 0;i < n ;i++){
            if(isValid(row, i, chessboard, n)){
                chessboard[row][i] = 'Q';
                backtracing(n, row + 1, chessboard);
                chessboard[row][i] = '.';
            }
        }
    }
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard (n , string(n , '.'));
        backtracing(n,0,chessboard);
        return result;
    }
};

37. 解数独

leetcode链接：力扣题目链接

视频链接：回溯算法二维递归？解数独不过如此！| LeetCode：37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：
[["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"]]

这题先跳过2333。

总结

回溯法一刷算是基本结束了，总结一下。

回溯法能解决的问题：

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

回溯三部曲

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

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

最后总结成图，感谢代码随想录知识星球 (opens new window)成员：莫非毛 (opens new window)，所画：