算法训练DAY30LeetCode332.重新安排行程51. N皇后37. 解数独

最新推荐文章于 2024-10-04 22:28:47 发布

Don Vito Corleone512

最新推荐文章于 2024-10-04 22:28:47 发布

阅读量46

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/weixin_66826367/article/details/131989593

版权

文章介绍了如何利用回溯算法来解决实际问题，如规划从JFK出发的旅行行程，以及经典计算机科学问题——N皇后问题和解数独。在旅行规划问题中，算法基于给定的航班信息找到可行的行程路径；在N皇后问题中，回溯法用于在棋盘上放置皇后，确保无冲突；解数独问题同样借助回溯策略，通过尝试填充数字并检查合法性来完成数独谜题。

摘要由CSDN通过智能技术生成

332.重新安排行程

class Solution {
public:
    vector<string> result;
    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;
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        for(vector<string>& vec: tickets){
            targets[vec[0]][vec[1]]++;
        }
        result.push_back("JFK");
        backtracking(tickets.size(),result);
        return result;
    }
};

51. N皇后

class Solution {
public:
    vector<vector<string>> result;
    void backtracking(int row,int n,vector<string>& chessboard){
        if(row==n){
            result.push_back(chessboard);
            return;
        }
        for(int i=0;i<n;i++){
            if(!check(chessboard,row,i,n))
                continue;
            chessboard[row][i] = 'Q';
            backtracking(row+1,n,chessboard);
            chessboard[row][i] = '.';
        }
    }
    bool check(vector<string>& chessboard,int row,int col,int n){
        for(int i=0;i<row;i++){
            if(chessboard[i][col] == 'Q'){
                return false;
            }
        }
        for(int i=row-1,j= col-1;i>=0&&j>=0;i--,j--){
            if(chessboard[i][j]=='Q')
                return false;
        }
        for(int i=row-1,j=col+1;i>=0&&j<n;i--,j++){
            if(chessboard[i][j]=='Q')
                return false;
        }
        return true;
    }
    vector<vector<string>> solveNQueens(int n) {
        std::vector<std::string> chessboard(n,std::string(n,'.'));
        backtracking(0,n,chessboard);
        return result;
    }
};

37. 解数独

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);
    }
};