LeetCode 37. Sudoku Solver

原题链接在此：https://leetcode.com/problems/sudoku-solver/

题目：

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

A sudoku solution must satisfy all of the following rules:

1. Each of the digits 1-9 must occur exactly once in each row.
2. Each of the digits 1-9 must occur exactly once in each column.
3. Each of the the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.

Empty cells are indicated by the character '.'.

A sudoku puzzle...

...and its solution numbers marked in red.

Note:

• The given board contain only digits 1-9 and the character '.'.
• You may assume that the given Sudoku puzzle will have a single unique solution.
• The given board size is always 9x9.

题解：

DFS needs state of board and current index.

DFS return value needs to indicate if we could fill the whole board.

For the current index, if if is '.', fill it with '1' to '9' and if it is valid, continue with next cell. If next cell return value is true, then we need to stop here, no backtracking, return true.

If it is not '.', then it is digit, return next one.

DFS returns boolean. This is a technique. When there is a valid answer, stop the DFS. Then DFS could return boolean and check if(DFS) then return to stop DFS.

Note: 1. 递归时当j == board[0].length 时, 应该是 return helper, 而不是单单的helper, 若是没有return, 会继续向下运行，到20行时就会out of index.

  2. 检查完isValid后直接检查是否继续递归是否有一个solution, 若是有就应该停下return.

Time Complexity: exponential.

Space: 递归最多会用O(board.length ^ 2)层stack.

AC Java: 

class Solution {
    public void solveSudoku(char[][] board) {
        if(board == null || board.length != 9 || board[0].length != 9){
            return;
        }
        
        dfsSolve(board, 0, 0);
    }
    
    private boolean dfsSolve(char [][] board, int i, int j){
        if(i == board.length){
            return true;
        }
        
        if(j == board[0].length){
            // get to next row
            return dfsSolve(board, i+1, 0);
        }
        
        if(board[i][j] == '.'){
            for(char c = '1'; c<='9'; c++){
                board[i][j] = c;
                if(isValid(board, i, j)){
                    // check if there is a solution, 如果这里有一个正确的solution就应该停下了
                    if(dfsSolve(board, i, j+1)){
                        return true;
                    }
                }
            }
            
            board[i][j] = '.';
        }else{
            // 这里已有数字，直接填本行下一个
            return dfsSolve(board, i, j+1);
        }
        
        return false;
    }
    
    private boolean isValid(char [][] board, int x, int y){
        for(int i = 0; i<9; i++){
            if(i != x && board[i][y] == board[x][y]){
                return false;
            }
        }
        
        for(int j = 0; j<9; j++){
            if(j != y && board[x][j] == board[x][y]){
                return false;
            }
        }
        
        int boxR = x / 3 * 3;
        int boxC = y / 3 * 3;
        for(int i = boxR; i < boxR + 3; i++){
            for(int j = boxC; j < boxC + 3; j++){
                if(i == x && j == y){
                    continue;
                }
                
                if(board[i][j] == board[x][y]){
                    return false;
                }
            }
        }
        
        return true;
    }
}

AC Python:

class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        self.dfs(board, 0, 0)
    
    def dfs(self, board: List[List[str]], i: int, j: int) -> bool:
        if i == 9:
            return True
        
        if j == 9:
            return self.dfs(board, i + 1, 0)
        
        if board[i][j] == '.':
            for c in range(1, 10):
                board[i][j] = str(c)
                if self.isValid(board, i, j):
                    if self.dfs(board, i, j + 1):
                        return True
            
            board[i][j] = '.'
        else:
            return self.dfs(board, i, j + 1)
        
        return False
    
    def isValid(self, board: List[List[str]], x: int, y: int) -> bool:
        for i in range(0, 9):            
            if i != x and board[i][y] == board[x][y]:
                return False
            
        for j in range(0, 9):
            if j != y and board[x][j] == board[x][y]:
                return False
            
        boxX = x // 3 * 3
        boxY = y // 3 * 3
        for i in range(boxX, boxX + 3):
            for j in range(boxY, boxY + 3):
                if i == x and j == y:
                    continue
                
                if board[i][j] == board[x][y]:
                    return False
                
        return True

类似Valid Sudoku, Unique Paths III.