Leetcode 题组 36（递归回溯）

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"]

分析：

这个问题的关键在于：每次递归搜索时，从某一结点出发，要首先从字典序最小的开始遍历，如果解决了这个问题，那剩下的工作就只剩下递归回溯了。然而 map 这一结构可以很方便的完成排序工作，我们可以使用一个 unordered_map<string, map<string, int>> ，外面这一层 unordered_map 存储的是 出发地 ，他的值对应的是 该出发地所有的目的地及目的地出现的次数，对于 <目的地，目的地出现次数> 我们使用 map 作为排序存储的容器。

class Solution {
public:

    unordered_map<string, map<string, int>> destinations;
    vector<string> ans;
    
    bool traceback(vector<vector<string>>& tickets, int route){
        if (route == 0) return true;
        for (pair<const string, int>& destination: destinations[ans.back()]) {
            if (destination.second) {
                ans.push_back(destination.first);
                --destination.second;
                // 在这里一旦找到一条，就可以返回，因为是从最小的字典序开始遍历的
                if (traceback(tickets, route-1)) return true;
                ++destination.second;
                ans.pop_back();
            }
        }
        return false;
    }

    vector<string> findItinerary(vector<vector<string>>& tickets) {
        destinations.clear();
        int route = 0;
        for (const vector<string>& vs: tickets) {
            ++destinations[vs[0]][vs[1]];
            ++route;
        }
        ans.push_back("JFK");
        traceback(tickets, route);
        return ans;
    }
};

 51. N 皇后

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

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

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

示例 1：

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

分析：

 这个问题的难点在于判断 在某一位置放置皇后后，该皇后是否有效。如果这一部分写好了，剩下就是递归回溯的问题了。

class Solution {
public:

    vector<vector<int>> path;
    vector<vector<string>> ans;

    bool isValue(int x, int y, int n){
        // 判断同一列是否冲突
        for (int i = 0; i < n; ++i) if (path[i][y]) return false;
        // 判断同一行是否冲突
        for (int i = 0; i < n; ++i) if (path[x][i]) return false;
        // 判断斜线方向是否冲突
        int tmp_x = x, tmp_y = y;
        while(tmp_x>=0 && tmp_y>=0) if (path[tmp_x--][tmp_y--]) return false;
        tmp_x = x, tmp_y = y;
        while(tmp_x>=0 && tmp_y<n) if (path[tmp_x--][tmp_y++]) return false;
        tmp_x = x, tmp_y = y;
        while(tmp_x<n && tmp_y>=0) if (path[tmp_x++][tmp_y--]) return false;
        tmp_x = x, tmp_y = y;
        while(tmp_x<n && tmp_y<n) if (path[tmp_x++][tmp_y++]) return false;
        return true;
    }

    void dfs(int cow, int n){
        if (cow == n){
            vector<string> tmp;
            for (int i = 0; i < n; ++i){
                string s ="";
                for (int j = 0; j < n; ++j){
                    if (path[i][j]) s += 'Q';
                    else s+='.';
                }
                tmp.push_back(s);
            }
            ans.push_back(tmp);
            return;
        }

        for (int i = 0; i < n; ++i){
            if (isValue(cow, i, n)){
                path[cow][i] = 1;
                dfs(cow+1, n);
                path[cow][i] = 0;
            }
        }
    }

    vector<vector<string>> solveNQueens(int n) {
        path.resize(n, vector<int>(n, 0));
        dfs(0, n);
        return ans;
    }
};

 37. 解数独

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

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

数字 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"]]

分析：

这个题目写起来不像是 N皇后 那样，而是采用两重搜索的方式，在递归内部实现对 x，y 的搜索。这个题唯一的难点在于如何写好 在某一位置放置一个数是否会冲突 。如果这个问题解决了，剩下的也就好办了。 

class Solution {
public:

    // 判断一个数是否会冲突
    bool isValid(vector<vector<char>>& board, int x, int y, char c) {
        // 在同一列上看
        for (int i = 0; i < 9; ++i) if (board[x][i] == c) return false;
        // 在同一行上看
        for (int i = 0; i < 9; ++i) if (board[i][y] == c) return false;
        // 在同一九宫格内看
        for (int i = x/3*3; i < (x/3+1)*3; ++i) {
            for (int j = y/3*3; j < (y/3+1)*3; ++j) {
                if (board[i][j]==c) return false;
            }
        }
        return true;
    }

    bool backtrace(vector<vector<char>>& board) {
        // 将搜索放置在递归函数内 这样不会引起无限递归
        // 因为在搜索不到可行解的时候就会返回false
        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;
                        // 当搜索到可行解时 直接返回true
                        if (backtrace(board)) return true;
                        board[i][j] = '.';
                    }
                }
                // 在该位置试遍了所有的可能性 1-9 返回false
                return false;
            }
        }
        // 已经出现了可行解 直接返回true
        return true;
    }

    void solveSudoku(vector<vector<char>>& board) {
        backtrace(board);
    }
};