37. 解数独

最新推荐文章于 2025-12-11 22:04:39 发布

原创最新推荐文章于 2025-12-11 22:04:39 发布 · 85 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #leetcode #算法 #数据结构

回溯算法专栏收录该内容

15 篇文章

订阅专栏

该博客介绍了一种优化的数独求解算法，通过使用位运算来存储每行、每列和每个宫格中已出现的数字，从而减少空间复杂度。这种方法将原本需要9个元素的数组降低到一个9位整数，提高了算法效率。博主还详细解释了递归回溯在解题过程中的应用，使得数独求解更为高效。

37. 解数独

class Solution {
    boolean[][] row = new boolean[9][9];
    boolean[][] colomn = new boolean[9][9];
    boolean[][][] block = new boolean[3][3][9];
    char[][] res = new char[9][9];
    public void solveSudoku(char[][] board) {

        for(int i = 0; i < 9;i++){
            for(int j = 0;j < 9;j++){
                if(board[i][j] != '.'){
                    int digit = board[i][j] - '0' - 1;
                    row[i][digit] = colomn[j][digit] = block[i/3][j/3][digit] = true;
                }
            }
        }
        backtracking(board,0,0);
        for(int i = 0; i < 9;i++){
            for(int j = 0; j < 9;j++){
                board[i][j] = res[i][j];
            }
        }
        
    }
    public void backtracking(char[][] board, int x, int y){
        if(x == 9){
            for(int i = 0; i < 9;i++){
                for(int j = 0; j < 9;j++){
                    res[i][j] = board[i][j];
                }
            }
            return;
        }
        
        if(board[x][y] != '.'){
            if(y == 8) backtracking(board,x + 1,0);
            else backtracking(board,x,y + 1);
        }else{
            for(int j = 0;j < 9;j++){
                char cur = transfer(j + 1);
                  
                if(!row[x][j] && !colomn[y][j] && !block[x/3][y/3][j]){
                    board[x][y] = cur;
                    row[x][j] = colomn[y][j] = block[x/3][y/3][j] = true;
                    if(y == 8) backtracking(board,x + 1,0);
                    else backtracking(board,x,y + 1);
                    row[x][j] = colomn[y][j] = block[x/3][y/3][j] = false;
                    board[x][y] = '.';
                }
            }
        }
    }
    public char transfer(int n){
        return (char)(n + '0');
    }
}

用row和colomn记录每行每列出现的数字，用block记录每个block记录出现过的数字，递归回溯即可。
还有更快的，用位运算，把本来需要长度为9的数组储存出现过的数字，用一个9位长度的整数储存数据。等于降了一个维度。