leetcode习题解答：37. Sudoku Solver

最新推荐文章于 2020-07-21 21:30:16 发布

overflow_1

最新推荐文章于 2020-07-21 21:30:16 发布

阅读量210

点赞数

本文链接：https://blog.youkuaiyun.com/overflow_1/article/details/78820082

版权

本文介绍了一种解决数独问题的算法实现，采用递归回溯的方法填充空缺单元格，确保唯一解的存在。通过分析空白格可能的情况，即唯一解、多解或无解，实现了数独的有效求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

难度：Hard

描述：

Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character '.'.

You may assume that there will be only one unique solution.

A sudoku puzzle...

...and its solution numbers marked in red.

思路：

这个题目让你写一个解数独的程序，我从来没解过数独，所以上网找了数独的算法，其实原理说起来很简单，就是对于空白格子，

可能有3种情况：

1.只能填一个数字，也就是说他所在的行列以及方块，已经出现了8个不同数字，只能填写剩下的一个。此时是唯一解

2.能填多个数字，这时需要递归下去求解，分别填进去去试。

3.一个都不能填，这时说明递归的上层填的数字不正确，需要返回到某个状态填另外的数字。

当我们发现所有空白都填完了就解出了数独。

验证某个格子可以填什么数，可以用一个set来统计其所在行列方格中的数字。

leetcode会给出非法的方格，可以把36题的验证函数放进来使用。

最开始时我的算法超时，因为我尝试填一个数时会再生成一个board，这很低效。经过修改全程使用一个board的引用。

代码：

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
    int row = board.size();
    int col = board.size();
    set<char> cs;
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if (board[i][j] == '.')continue;
            if (cs.find(board[i][j]) == cs.end()) {
                cs.insert(board[i][j]);
            }
            else {
                return false;
            }
        }
        cs.clear();
    }
    for (int j = 0; j < col; j++) {
        for (int i = 0; i < row; i++) {
            if (board[i][j] == '.')continue;
            if (cs.find(board[i][j]) == cs.end()) {
                cs.insert(board[i][j]);
            }
            else {
                return false;
            }
        }
        cs.clear();
    }
    for (int i = 0; i < row; i += 3) {
        for (int j = 0; j < col; j += 3) {
            for (int k = i; k < i + 3; k++) {
                for (int z = j; z <j + 3; z++) {
                    if (board[k][z] == '.')continue;
                    if (cs.find(board[k][z]) == cs.end()) {
                        cs.insert(board[k][z]);
                    }
                    else {
            
                        return false;
                    }
                }
            }
            cs.clear();
        }
    }
    return true;
}

    void check(vector<vector<char>>& board,int row,int col,set<char>& around){
        for (int k = 0; k < 9; k++){
            if (k == col)continue;
            if (board[row][k] != '.') around.insert(board[row][k]);
        }
        for (int k = 0; k < 9; k++){
            if (k == row)continue;
            if (board[k][col] != '.') around.insert(board[k][col]);
        }
        int row_start = (row/3)*3;
        int col_start = (col/3)*3;
        for (int k = row_start; k < row_start+3; k++){
            for (int z = col_start; z < col_start+3; z++){
                if (k == row && z == col)continue;
                if (board[k][z] != '.') around.insert(board[k][z]);
            }
        }
    }
    bool solve(vector<vector<char>>& board, vector<vector<char>>& result) {
        int filled = 0; 
        set<char> around;
        for(int i = 0; i < 9; i++){
            for (int j = 0; j < 9; j++){
                if (board[i][j] == '.'){
                    check(board,i,j,around);
                    if(around.size()< 9){
                        for (int k = 1; k <= 9; k++){
                            char c = '0'+k;
                            if (around.find(c) == around.end()){
                                board[i][j] = c;
                                if (solve(board,result)) return true;
                            }
                        }
                        board[i][j] = '.';
                        return false;
                    } else if(around.size() == 9){
                        return false;
                    }
                } else {
                    filled++;
                }
                around.clear();
            }
        }
        if (filled == 81) {
            result = board;
            return true;
        }
        return false;
    }
    void solveSudoku(vector<vector<char>>& board) {
        if (isValidSudoku(board) == false) return;
        vector<vector<char>> begin = board;
        solve(begin,board);
    }
};