代码随想录算法训练营第30天| 332.重新安排行程 、51. N皇后 、 37. 解数独

代码随想录算法训练营第30天| 332.重新安排行程 、51. N皇后 、 37. 解数独

332.重新安排行程

开始想的是将行程进行全排列之后，然后选出一个字典排序最小的。就也是使用的回溯的思路。

class Solution {
private:
    vector<vector<string>> res;
    vector<string> path;
    int ticketUsed = 0;
    bool cmp(const vector<string> &a, const vector<string> &b) {
        for (int i = 0; i < b.size(); ++i) {
            if (a[i] == b[i]) continue; //跳出循环
            return a[i] < b[i] ? true : false;
        }
        return false;
    }
    void backtracking(vector<vector<string>> &tickets, vector<bool>& used, string airport) {
        if (ticketUsed == tickets.size()) {
            res.push_back(path);
            return;
        }

        for (int i = 0; i < tickets.size(); i++) {
            if (tickets[i][0] == airport && used[i] == false) {
                used[i] = true;
                ticketUsed++;
                path.push_back(tickets[i][1]);
                backtracking(tickets, used, tickets[i][1]);
                used[i] = false;
                ticketUsed--;
                path.pop_back();
            }
        }
    }

public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<bool> used(tickets.size(), false);
        path.push_back("JFK");
        backtracking(tickets, used, "JFK");
        sort(res.begin(), res.end(), cmp);
        return res[0];
    }
};

使用了其他的数据结构进行去重

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> res;
        for(const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++;
        }
        res.push_back("JFK");  //起始机场
        backtracking(tickets.size(), res);
        return res;
    }
};

51. N皇后

本题是使用回溯法的经典问题。

里面有一步就是验证放了之后，是否有冲突。 因为是从上往下一层层的在填充，所以就不用考虑 更下一层是否会有皇后。而且，也不需要考虑行

bool inValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; ++i) {
        if (cheese[i][col] == 'Q')
            return false;
    }
    // 135° 检查是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; --i, --j) {
        if (cheese[i][col] == 'Q')
            return false;
    }
    // 45°检查是否有皇后
    for (int i = row - 1, j = col + 1; i >= 0 && j <= n -1; --i, ++j) {
        if (cheese[i][col] == 'Q')
            return false;
    }
    return true;
}

class Solution {
private:
   vector<vector<string> > result;
    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;
        }
    }
    //135° 检查是否有皇后
    for(int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
        if(chessboard[i][j] == 'Q') {
            return false;
        }
    }
    //45°检查是否有皇后
    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();
        vector<string> chessboard(n, string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

37. 解数独

在看了n皇后之后，再看数独，这种填充问题，感觉就是得用回溯法。

横向的for循环来控制要填什么，纵向的递归就是在寻找一个可以填的空位。

class Solution {
private:
    bool isValid(int row, int col, char val, vector<vector<char>>& board) {
        // 一行里面是否有重复
        for (int i = 0; i < 9; ++i) {
            if (board[row][9] == val)
                return false;
        }
        // 一列里面是否有重复
        for (int i = 0; i < 9; ++i) {
            if (board[i][col] == val)
                return false;
        }
        // 判断九方格里面是否有重复
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; ++i) {
            for (int j = startCol; j < startCol + 3; ++j) {
                if (board[i][j] == val)
                    return false;
            }
        }
        return true;
    }
    
    bool backtracking(vector<vector<char>>& board) {
        // 要遍历完整个树，所以不设置终止条件
        for (int i = 0; i < board.size(); ++i) {
            for (int j = 0; j < board.size(); ++j) {
                if (board[i][j] == '.') {
                    for (char k = '1'; k <= '9'; ++k) {
                        if (isValid(i, j, k, board)) {
                            board[i][j] = k;
                            if (backtracking(board) == true)
                                return true;
                            board[i][j] = '.'; //回溯
                        }
                    }
                    // 9个数字都不行
                    return false;
                }
            }
        }
        return true;
    }
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};