代码随想录刷题Day30 | 332.重新安排行程 | 51. N皇后 | 37. 解数独

代码随想录刷题Day30 | 332.重新安排行程 | 51. N皇后 | 37. 解数独

332.重新安排行程

题目：

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

提示：

• 如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前
• 所有的机场都用三个大写字母表示（机场代码）。
• 假定所有机票至少存在一种合理的行程。
• 所有的机票必须都用一次 且 只能用一次。

示例 1：

• 输入：[[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
• 输出：[“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]

示例 2：

• 输入：[[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
• 输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
• 解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”]。但是它自然排序更大更靠后。

思路：

代码：

51. N皇后

题目：

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

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

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

示例 1：

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

示例 2：

• 输入：n = 1
• 输出：[[“Q”]

思路：

从图中，可以看出，二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。

那么我们用皇后们的约束条件，来回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

代码：

class Solution {
    List<List<String>> result = new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        char[][] path = new char[n][n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                path[i][j] = '.';
            }
        }
        backTracking(n, 0, path);
        return result;
    }
    public void backTracking(int n, int row, char[][] path){
        if(row == n){
            result.add(list2list(path));
            return;
        }
        for(int col = 0; col < n; col++){
            if(isVaild(col, row, n, path)){
                path[row][col] = 'Q';
                backTracking(n, row + 1, path);
                path[row][col] = '.';
            }
        }
    }
    public List<String> list2list(char[][] p){
        List<String> r = new ArrayList<>();
        for(int i = 0; i < p.length; i++){
            r.add(new String(p[i]));
        }
        return r;
    }
    public boolean isVaild(int col, int row, int n, char[][] path ){
        for(int i = row; i >= 0; --i){
            if(path[i][col] == 'Q') return false;
        }
        for(int i = col, j = row; i >= 0 && j >= 0; --i, --j){
            if(path[j][i] == 'Q') return false;
        }
        for(int i = col, j = row; i < n && j >= 0; ++i, --j){
            if(path[j][i] == 'Q') return false;
        }
        return true;
    }
}

37. 解数独

题目：

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

一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。

一个数独。

答案被标成红色。

提示：

• 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。
• 你可以假设给定的数独只有唯一解。
• 给定数独永远是 9x9 形式的。

思路：

在树形图中可以看出我们需要的是一个二维的递归（也就是两个for循环嵌套着递归）

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

代码：

class Solution {
    public void solveSudoku(char[][] board) {
        backTracking(board);
    }
    public boolean backTracking(char[][] board){
        for(int i = 0; i < 9; i++){
            for(int j = 0; j < 9; j++){
                if(board[i][j] != '.') continue;
                for(char c = '1'; c <= '9'; c++){
                    if(isVaild(i, j, c, board)){
                        board[i][j] = c;
                        if(backTracking(board)){
                            return true;
                        }
                        board[i][j] = '.';
                    }
                }
                return false;
            }
        }
        return true;
    }
    public boolean isVaild(int row, int col, char val, 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++){
            for (int j = startCol; j < startCol + 3; j++){
                if (board[i][j] == val){
                    return false;
                }
            }
        }
        return true;
    }
}