算法日记day 27（回溯之N皇后|解数独）

一、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"]]

思路：

主要在于处理逻辑，需要处理上下左右两方，还有斜45度和斜135度是否存在皇后，如果都不存在才可以将皇后放入对应的结果数组中，若存在则不能放入，继续判断下一个地区是否可行

代码：

class Solution {
    // 用于存储所有解决方案的列表
    List<List<String>> result = new ArrayList<>();

    // 主方法，解决N皇后问题
    public List<List<String>> solveNQueens(int n) {
        // 创建一个大小为n x n的字符数组表示棋盘
        char[][] chessboard = new char[n][n];
        
        // 初始化棋盘，所有格子都用'.'表示空
        for (char[] c : chessboard) {
            Arrays.fill(c, '.');
        }
        
        // 从第一行开始回溯求解
        backtracking(chessboard, n, 0);
        
        // 返回所有的解决方案
        return result;
    }

    // 将二维字符数组转换为字符串列表
    public List<String> ArrayList2(char[][] chessboard) {
        List<String> list = new ArrayList<>();
        for (char[] c : chessboard) {
            //String.copyValueOf(char[]) 方法用于创建一个新的字符串，其内容是指定字符数组中的字符序列
            list.add(String.copyValueOf(c));
        }
        return list;
    }

    // 回溯方法，探索所有解决方案
    public void backtracking(char[][] chessboard, int n, int row) {
        // 如果已经成功放置了所有皇后，将当前棋盘状态加入结果集
        if (row == n) {
            result.add(ArrayList2(chessboard));
            return;
        }
        
        // 尝试当前行的每一列放置皇后
        for (int col = 0; col < n; col++) {
            // 检查当前位置是否可以放置皇后
            if (isValid(chessboard, n, row, col)) {
                // 放置皇后
                chessboard[row][col] = 'Q';
                
                // 递归处理下一行
                backtracking(chessboard, n, row + 1);
                
                // 回溯，撤销当前位置的皇后
                chessboard[row][col] = '.';
            }
        }
    }

    // 检查在特定位置放置皇后是否有效
    public boolean isValid(char[][] chessboard, int n, int row, int col) {
        // 检查列是否有其他皇后
        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;
            }
        }
        
        // 如果当前位置可以放置皇后，则返回true
        return true;
    }
}

1. 类声明和成员变量:

   • List<List<String>> result = new ArrayList<>();：用于存储所有可能的解决方案。

2. solveNQueens 方法:

   • 创建一个 n x n 的字符数组 chessboard，用于表示棋盘。
   • 初始化棋盘，所有格子用.表示空。
   • 调用 backtracking 方法开始求解N皇后问题。
   • 返回存储在 result 中的所有解决方案。

3. ArrayList2 方法:

   • 将二维字符数组 chessboard 转换为字符串列表 List<String>，每个字符串表示棋盘的一行。

4. backtracking 方法:

   • 如果已经成功放置了所有皇后（row == n），将当前棋盘状态加入 result。
   • 遍历当前行的每一列，尝试放置皇后。
   • 使用 isValid 方法检查在当前位置 (row, col) 放置皇后是否有效。
   • 递归调用 backtracking 处理下一行。
   • 回溯：在返回前撤销当前位置的皇后。

5. isValid 方法:

   • 检查在棋盘的特定位置 (row, col) 放置皇后是否符合规则：
     • 检查同一列是否有其他皇后。
     • 检查左上对角线和右上对角线是否有其他皇后。

二、解数独 

题目：

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

数独的解法需 遵循如下规则：

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

思路：

双层for循环分别遍历行和列，为了方便查找，在遍历第一行和列后如果没用满足的条件直接返回不在深入遍历，如果满足则继续遍历，当遍历完后如果没用返回则说明找到答案，其中应该判断行，列，3×3的九宫格中是否有重复的元素

代码：

public void solveSudoku(char[][] board) {
    solveSudokuHelper(board);
}
private boolean solveSudokuHelper(char[][] board) {
    for (int i = 0; i < 9; i++) { // 遍历行
        for (int j = 0; j < 9; j++) { // 遍历列
            if (board[i][j] != '.') { // 跳过已经填入的数字
                continue;
            }
            for (char k = '1'; k <= '9'; k++) { // 尝试填入 '1' 到 '9'
                if (isValidSudoku(i, j, k, board)) {
                    board[i][j] = k; // 填入数字 k
                    if (solveSudokuHelper(board)) { // 递归尝试填下一个位置
                        return true;
                    }
                    board[i][j] = '.'; // 回溯，重置为 '.'
                }
            }
            //如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解
            return false;
        }
    }
    return true; // 棋盘填满，找到解决方案
}
private boolean isValidSudoku(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;
        }
    }
    // 检查 3x3 宫格是否重复,分别从0，3，6的位置开始检查
    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;
}

• 如果当前位置已经填入数字（不是'.'），则跳过继续下一个位置。
• 否则，尝试填入数字 '1' 到 '9'，并调用 isValidSudoku 方法检查当前填入的数字是否符合数独规则。
• 如果符合规则，则继续递归调用 solveSudokuHelper 去尝试填写下一个位置。
• 如果递归调用返回 true，表示找到了合适的解决方案，立即返回 true。
• 如果递归调用返回 false，表示当前尝试的数字不符合条件，需要回溯，将当前位置重新设为 '.'，然后尝试下一个数字。