代码随想录算法训练营第36期DAY32

DAY32

回溯算法总结

同一树层去重的两种方法：90子集ii

class Solution {private:

    vector<vector<int>> result;

    vector<int> path;

    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {

        result.push_back(path);

        for (int i = startIndex; i < nums.size(); i++) {

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

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

            // 而我们要对同一树层使用过的元素进行跳过

            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {

                continue;

            }

            path.push_back(nums[i]);

            used[i] = true;

            backtracking(nums, i + 1, used);

            used[i] = false;

            path.pop_back();

        }

    }

public:

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {

        result.clear();

        path.clear();

        vector<bool> used(nums.size(), false);

        sort(nums.begin(), nums.end()); // 去重需要排序

        backtracking(nums, 0, used);

        return result;

    }};

class Solution {private:

    vector<vector<int>> result;

    vector<int> path;

    void backtracking(vector<int>& nums, int startIndex) {

        result.push_back(path);

        unordered_set<int> uset;

        for (int i = startIndex; i < nums.size(); i++) {

            if (uset.find(nums[i]) != uset.end()) {

                continue;

            }

            uset.insert(nums[i]);

            path.push_back(nums[i]);

            backtracking(nums, i + 1);

            path.pop_back();

        }

    }

public:

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {

        result.clear();

        path.clear();

        sort(nums.begin(), nums.end()); // 去重需要排序

        backtracking(nums, 0);

        return result;

    }};

使用set针对同一父节点本层去重

332重新安排行程

已经刷很多次了。

class Solution {private:// unordered_map<出发机场, map<到达机场, 航班次数>> targets

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

    if (result.size() == ticketNum + 1) {

        return true;

    }

    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;}public:

    vector<string> findItinerary(vector<vector<string>>& tickets) {

        targets.clear();

        vector<string> result;

        for (const vector<string>& vec : tickets) {

            targets[vec[0]][vec[1]]++; // 记录映射关系

        }

        result.push_back("JFK"); // 起始机场

        backtracking(tickets.size(), result);

        return result;

    }};

51N皇后

已经刷很多次了。

语法：二维vector:

多变量的终止条件写法：

这样写是错的：

1.  for(int i=row-1,j=col-1;i>=0，j>=0;i--,j--)

要&&

1. for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--)

class Solution {private:

vector<vector<string>> result;// n 为输入的棋盘大小// row 是当前递归到棋盘的第几行了void backtracking(int n, int row, vector<string>& chessboard) {

    if (row == n) {

        result.push_back(chessboard);

        return;

    }

    for (int col = 0; col < n; col++) {

        if (isValid(row, col, chessboard, n)) { // 验证合法就可以放

            chessboard[row][col] = 'Q'; // 放置皇后

            backtracking(n, row + 1, chessboard);

            chessboard[row][col] = '.'; // 回溯，撤销皇后

        }

    }}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;}public:

    vector<vector<string>> solveNQueens(int n) {

        result.clear();

        std::vector<std::string> chessboard(n, std::string(n, '.'));

        backtracking(n, 0, chessboard);

        return result;

    }};

37解数独

“搜索整个树形结构用void backtracking();搜索单个树枝用bool backtracking()”

已经刷很多次了。

class Solution {private: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] == '.') {

                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;}public:

    void solveSudoku(vector<vector<char>>& board) {

        backtracking(board);

    }};