_26LeetCode代码随想录算法训练营第二十六天-回溯算法 | 332.重新安排行程 、51.N皇后、37.解数独

_26LeetCode代码随想录算法训练营第二十六天-回溯算法 | 332.重新安排行程 、51.N皇后、37.解数独

题目列表

• 332.重新安排行程
• 51.N皇后
• 37.解数独
• 总结

332.重新安排行程

代码随想录地址：

https://programmercarl.com/0332.%E9%87%8D%E6%96%B0%E5%AE%89%E6%8E%92%E8%A1%8C%E7%A8%8B.html

题目

给你一份航线列表 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
• $fro{m}_i$.length == 3
• $t{o}_i$.length == 3
• $fro{m}_i$和 $t{o}_i$ 由大写英文字母组成
• $from_i $!= $t{o}_i$

思路

难点

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

记录映射关系

一个机场映射多个机场，机场之间要靠字母序排列，一个机场映射多个机场，可以使用std::unordered_map，如果让多个机场之间再有顺序的话，就是用std::map 或者std::multimap 或者 std::multiset。

因此可选的映射关系为：unordered_map<string, multiset> targets或者unordered_map<string, map<string, int>> targets。

含义如下：

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

unordered_map<string, map<string, int>> targets：unordered_map<出发机场, map<到达机场, 航班次数>> targets

这两个结构，选择后者，因为如果使用unordered_map<string, multiset<string>> targets 遍历multiset的时候，不能删除元素，一旦删除元素，迭代器就失效了。

策略：在遍历 unordered_map<出发机场, map<到达机场, 航班次数>> targets的过程中，可以使用"航班次数"这个字段的数字做相应的增减，来标记到达机场是否使用过了。

如果“航班次数”大于零，说明目的地还可以飞，如果“航班次数”等于零说明目的地不能飞了，而不用对集合做删除元素或者增加元素的操作。

回溯思路

个人感想

本题个人感觉较难，较难的点在于哈希表的选择。

代码

/*
 * @lc app=leetcode.cn id=332 lang=cpp
 *
 * [332] 重新安排行程
 */

// @lc code=start
class Solution {
private:
    unordered_map<string, map<string, int>> targets;
    //targets是排序的，先找的是字符比较小的
    //找到结果就返回true
    bool backtracking(int ticketsNum, vector<string>& res)
    {
        //终止条件
        //就是找到了合适的航班顺序
        if(res.size() == ticketsNum + 1)
            return true;
        //单层for循环
        //找到res末尾元素(城市)出发的航班
        for(pair<const string, int>& data : targets[res[res.size()-1]])
        {
            //如果航班还未使用
            if(data.second > 0)
            {
                res.push_back(data.first);
                data.second--;//还有这么多票还未使用
                if(backtracking(ticketsNum, res)) return true;//递归
                data.second++;//回溯
                res.pop_back();//回溯
            }
        }
        return false;//没找到就返回false
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> res;
        //使用map存储航班
        for(const vector<string>& data : tickets)
            targets[data[0]][data[1]]++;
        res.push_back("JFK");//需要将出发地放入结果集
        backtracking(tickets.size(), res);
        return res;
    }
};
// @lc code=end

51.N皇后

代码随想录地址：

https://programmercarl.com/0051.N%E7%9A%87%E5%90%8E.html

题目

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

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

思路

行表示树的宽度，列表示递归的深度。

代码

/*
 * @lc app=leetcode.cn id=51 lang=cpp
 *
 * [51] N 皇后
 */

// @lc code=start
class Solution {
private:
    vector<vector<string>> res;
    //判断将皇后放到行row，列col是否合法
    bool isValid(int row, int col, vector<string>& chess, int n)
    {
        //为什么不判断行是否合法，因为是按行放皇后的，一行一定不会出现两个及以上的皇后
        //判断列是否合法
        for(int i = 0; i < row; i++)
        {
            if(chess[i][col] == 'Q')
                return false;
        }
        //判断45度角
        for(int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--,j--)
        {
            if(chess[i][j] == 'Q')
                return false;
        }
        //判断135度角
        for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--,j++)
        {
            if(chess[i][j] == 'Q')
                return false;
        }
        return true;//前面都没有返回false，则是合法的
    }
    //n表示棋盘的大小
    //row表示递归到第几行了
    void backtracking(int n, int row, vector<string>& chess)
    {
        if(n == row)
        {
            res.push_back(chess);
            return;
        }
        //这里就是判断是第几列
        for(int i = 0; i < n; i++)
        {
            //当放到这一列符合要求时
            if(isValid(row, i, chess, n))
            {
                chess[row][i] = 'Q';
                backtracking(n, row + 1, chess);
                chess[row][i] = '.';
            }
        }
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        res.clear();
        //这里不写std::也没有问题
        vector<string> chess(n, string(n, '.'));
        backtracking(n, 0, chess);
        return res;
    }
};
// @lc code=end

37.解数独

代码随想录地址：

https://programmercarl.com/0037.%E8%A7%A3%E6%95%B0%E7%8B%AC.html

题目

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

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

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 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"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

提示：

• board.length == 9
• board[i].length == 9
• board[i][j] 是一位数字或者 '.'
• 题目数据 保证 输入数独仅有一个解

思路

代码

/*
 * @lc app=leetcode.cn id=37 lang=cpp
 *
 * [37] 解数独
 */

// @lc code=start
class Solution {
private:
    bool isValid(int row, int col, char ch, vector<vector<char>>& board)
    {
        //判断行
        for(int i = 0; i < board[row].size(); i++)
            if(board[row][i] == ch)
                return false;
        //判断列
        for(int j = 0; j < board.size(); j++)
            if(board[j][col] == ch)
                return false;
        int beginRow = (row/3) * 3;
        int beginCol = (col/3) * 3;
        for(int i = beginRow; i < beginRow + 3; i++)
            for(int j = beginCol; j < beginCol + 3; j++)
                if(board[i][j] == ch)
                    return false;
        return true;//都没有返回false，符合要求，返回true
    }
    bool backtracking(vector<vector<char>>& board)
    {
        //不需要终止条件，因为遍历到位会自动结束
        for(int i = 0; i < board.size(); i++)//行
            for(int j = 0; j < board[i].size(); j++)//列
                if(board[i][j] == '.')//只有在元素为.时需要处理
                {
                    for(char ch = '1'; ch <= '9'; ch++)
                    {
                        if(isValid(i, j, ch, board))//如果满足要求
                        {
                            board[i][j] = ch;
                            if(backtracking(board))//递归
                                return true;//如果上一层返回了true，则直接返回true
                            //回溯
                            board[i][j] = '.';
                        }
                    }
                    return false;//九个数字都试完了，不可以就返回false
                }
        return true;//所有的数字都填满了，满足要求
    }
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};
// @lc code=end

总结

代码随想录地址：

https://programmercarl.com/%E5%9B%9E%E6%BA%AF%E6%80%BB%E7%BB%93.html