leetcode：37. 解数独

题目来源

• sudoku-solver

题目描述

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {

    }
};

题目解析

所有的棋盘搜索问题都可以使用回溯法暴力搜索，只不过这里我们要做的是二维递归

N皇后也是二维递归，但是因为它每一行每一列只放一个皇后，所以只需要一层for循环遍历一行，递归来遍历列，然后一行一行的确定皇后的唯一位置。

而本题中棋盘的每一个位置都要放一个数字，并检测数字是否合法，解树独的树形结构要比N皇后更深，比如：

class Solution {
private:
    // 检验[row][col]位置能够合法插入val
    bool isValid(vector<vector<char>>& board, int row, int col, char val)
    {
        // 检验要插入的val在这行是否重复
        for (int i = 0; i < 9; i++)
        {
            if (board[row][i] == val)   return false;
        }
        // 检验要插入的val在这列是否重复
        for (int i = 0; i < 9; i++)
        {
            if (board[i][col] == val)   return false;
        }
        // 定位[row][col]位置所在的那个九宫格的左上角坐标（ 当前 3x3 宫内有没有重复的）
        int x = (row / 3) * 3;
        int y = (col / 3) * 3;
        // 检验要插入的val在九宫格中是否重复
        for (int i = x; i < x + 3; i++)
        {
            for (int j = y; j < y + 3; j++)
            {
                if (board[i][j] == val) return false;
            }
        }
        return true;
    }
    // 返回值为bool类型，找到一组解就返回
    bool dfs(vector<vector<char>>& board)
    {
        // 遍历数独盘的的每一行
        for (int i = 0; i < 9; i++)
        {
            // 遍历数独盘的的每一列
            for (int j = 0; j < 9; j++)
            {
                if (board[i][j] != '.') continue;   // 此位置不是空白格，跳过
                // 依次尝试1~9
                for (char k = '1'; k <= '9'; k++)
                {
                    if (! isValid(board, i, j, k))  continue;
                    board[i][j] = k;    // 做出选择
                    if (dfs(board)) return true;
                    board[i][j] = '.';  // 撤销选择，回溯
                }
                return false;   // 此位置没有能插入的数字，此数独盘无可行解
            }
        }
        return true;    // 每个位置都得到了合法值，得到可行解
    }

public:
    void solveSudoku(vector<vector<char>>& board) 
    {
        dfs(board);    
    }
};

优化写法

class Solution {
    bool row[9][10] = {false};
    bool col[9][10] = {false};
    bool bucket[9][10] = {false};

    void initMaps(vector<vector<char>>& board){
        for (int i = 0; i < 9; ++i) {
            for (int j = 0; j < 9; ++j) {
                int bid = (i / 3) * 3 + (j / 3);
                if(board[i][j] != '.'){
                    int num = board[i][j] - '0';
                    row[i][num] = true;
                    col[j][num] = true;
                    bucket[bid][num] = true;
                }
            }
        }
    }

    //  当前来到(i,j)这个位置，如果已经有数字，跳到下一个位置上
    //                      如果没有数字，尝试1~9，不能和row、col、bucket冲突
    bool process(vector<vector<char>>& board, int i, int j){
        if(i == 9){
            return true;
        }

        // 当离开(i，j)，应该去哪？(nexti, nextj)
        int nexti = j != 8 ? i : i + 1;
        int nextj = j != 8 ? j + 1 : 0;
        if(board[i][j] != '.'){
            return process(board, nexti, nextj);
        }else{
            int bid = 3 * (i / 3) + (j / 3);
            for (char k = '1'; k <= '9'; ++k) {
                int idx = k - '0';
                if(row[i][idx] || col[j][idx] || bucket[bid][idx]){
                    continue;
                }
                board[i][j] = k;
                row[i][idx] = true;
                col[j][idx] = true;
                bucket[bid][idx] = true;
                if(process(board, nexti, nextj)){
                    return true;
                }
                row[i][idx] = false;
                col[j][idx] = false;
                bucket[bid][idx] = false;
                board[i][j] = '.';
            }
            return false;
        }
    }
public:
    void solveSudoku(vector<vector<char>>& board) {
        initMaps(board);
        process(board, 0, 0);
    }
};

类似题目

题目	思路
leetcode：36. 有效的数独 Valid Sudoku
leetcode：37. 解数独Sudoku Solver
leetcode：980. 不同路径 III Sudoku Solver
leetcode：212. 单词搜索 II Word Search II