C++刷题笔记(31)——全排列leetcode46、47，leetcode332，棋盘问题lettcode51、37

题目1：46.全排列

排列和组合的不同就在于，在排序中[1,2]、[2,1]是两个集合，在组合中这两个是一个集合，同一个数需要使用多次，也就不需要start来标记下一次遍历的位置。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used) {
        if (path.size() == nums.size()) {         //收集元素的数组大小等于nums数组，说明找到了一个全排列
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue;        //path里已经收集过的元素，直接跳过
            used[i] = true;                       //如果apth里没有收集过，则将其置为1
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();                      //回溯
            used[i] = false;                      //回溯
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

题目2：47.全排列Ⅱ

和上一题的区别在于不允许有重复的排列了，那么按照之前的套路进行去重

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used) {
        if (path.size() == nums.size()) {         //收集元素的数组大小等于nums数组，说明找到了一个全排列
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            //used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            //used[i - 1] == false，说明同一树层nums[i - 1]使用过，直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

题目3：332.重新安排行程

这道题的意思就是遍历所有的城市(节点)，找出遍历路径

class Solution {
public:
    unordered_map<string, map<string, int>> targets;   //unordered_map<出发机场, map<到达机场, 航班次数>>，记录映射关系，通过航班次数来标记到达机场是否使用过(>0可飞、=0不能飞)
    bool backtracking(int ticketnum, vector<string>& result) {            //ticketnum表示有多少个航班
        if (result.size() == ticketnum + 1) return true;                  //机场个数=航班数+1，即找到了一条遍历路径
        for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
            if (target.second > 0) {                                      //记录机场是否飞过了
                result.push_back(target.first);
                target.second--;
                if (backtracking(ticketnum, result)) return true;
                result.pop_back();
                target.second++;
            }
        }
        return false;
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<string> result;
        for (const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++;                //记录映射关系
        }
        result.push_back("JFK");                      //加入起始机场
        backtracking(tickets.size(), result);
        return result;
    }
};

没整明白，先贴上代码

题目4：51.N皇后

皇后的走法是：可以横直斜走，格数不限。因此要求皇后彼此之间不能相互攻击，等价于要求任何两个皇后都不能在同一行、同一列以及同一条斜线上。

思路其实和之前的回溯算法的题差不多感觉

class Solution {
public:
    vector<vector<string>> result;
    void backtracking(int n, int x, vector<string>& chessboard) {   //n是棋盘大小、x为棋盘的行
        if (x == n) {                                               //遍历到棋盘的最底层
            result.push_back(chessboard);
            return;
        }
        for (int y = 0; y < n; y++) {                               //y为棋盘的列
            if (isvaild(x, y, chessboard, n)) {                     //判断要放置的皇后是否合法，isvaild为1时才会放置皇后
                chessboard[x][y] = 'Q';                             //放置皇后
                backtracking(n, x + 1, chessboard);                 //递归，进入下一行
                chessboard[x][y] = '.';                             //回溯，将Q替换回.
            }
        }
    }
    bool isvaild(int x, int y, vector<string>& chessboard, int n) {   //不需要判断同行有没有Q
        for (int i = 0; i < x; i++) {                                 //检验竖列有没有Q
            if (chessboard[i][y] == 'Q') return false;
        }
        for (int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {  //检验左上有没有Q
            if (chessboard[i][j] == 'Q') return false;
        }
        for (int i = x - 1, j = y + 1; i >= 0 && j < n; i--, j++) {   //检验右下有没有Q
            if (chessboard[i][j] == 'Q') return false;
        }
        return true;
    }
    vector<vector<string>> solveNQueens(int n) {
        string s(n, '.');                                             //代表每一行的棋盘情况，n个.
        vector<string> chessboard(n, s);                              //棋盘初始化全为 . ，放置棋子就在对应位置替换成 Q
        backtracking(n, 0, chessboard);
        return result;
    }
};

题目5：37.解数独

这比N皇后还猛

class Solution {
public:
    bool backtracking(vector<vector<char>>& board) {    //不需要终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回
        for (int i = 0; i < board.size(); i++) {        // 遍历行
            for (int j = 0; j < board[0].size(); j++) { // 遍历列
                if (board[i][j] != '.') continue;
                for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                    if (isValid(i, j, k, board)) {
                        board[i][j] = k;                // 放置k
                        if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                        board[i][j] = '.';              // 回溯，撤销k
                    }
                }
                return false;                           // 9个数都试完了，都不行，那么就返回false
            }
        }
        return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
    }
    bool isValid(int row, int col, char val, vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) { // 判断行里是否重复
            if (board[row][i] == val) {
                return false;
            }
        }
        for (int j = 0; j < 9; j++) { // 判断列里是否重复
            if (board[j][col] == val) {
                return false;
            }
        }
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
            for (int j = startCol; j < startCol + 3; j++) {
                if (board[i][j] == val) {
                    return false;
                }
            }
        }
        return true;
    }
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};