Leetcode: Sudoku Solver

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.

又是一道NP的问题，这种问题时间复杂度就不用考虑了，肯定是指数量级的，参考了一下别人的思路，这道题的思路与N-Queens，Permutations问题比较相似, 简单地说思路就是循环处理子问题，对于每个格子，带入不同的9个数，然后判合法，如果成立就递归继续。判合法可以用Valid Sudoku做为subroutine，但是其实在这里因为每次进入时已经保证之前的board不会冲突，所以不需要判断整个盘，只需要看当前加入的数字和之前是否冲突就可以，这样可以大大提高运行效率，毕竟判合法在程序中被多次调用。

第二遍做法：

public class Solution {
    public void solveSudoku(char[][] board) {
        if (board == null || board.length != 9 || board[0].length != 9) return;
        helper(board, 0, 0);
    }
    
    public boolean helper(char[][] board, int i, int j) {
        if (j == 9) return helper(board, i+1, 0);
        if (i == 9) return true;
        if (board[i][j] != '.') return helper(board, i, j+1);
        for (int k=0; k<9; k++) {
            board[i][j] = (char)('1' + k);
            if (check(board, i, j)) {
                if (helper(board, i, j+1)) return true;
            }
        }
        board[i][j] = '.';
        return false;
    }
    
    public boolean check(char[][] board, int i, int j) {
        for (int t=0; t<9; t++) {
            if (t != i && board[t][j] == board[i][j]) return false;
        }
        for (int t=0; t<9; t++) {
            if (t != j && board[i][t] == board[i][j]) return false; 
        }
        for (int s=i/3*3; s<i/3*3+3; s++) {
            for (int t=j/3*3; t<j/3*3+3; t++) {
                if (s!=i || t!=j) {
                    if(board[s][t] == board[i][j]) return false;
                }
            }
        }
        return true;
    }
}

17行一定要记得在return false之前把board[i][j] 改回‘.’, 否则会出很严重的错误：比如board[i][j+1]把1~9都试过都不是valid的，这时候要回到board[i][j]去换另一个数试一试，再进入board[i][j+1]，由于刚才已经把它改成1~9了而且没有改回‘.’，所以递归就会沿着一条错误的路走下去。最后会得到一组明显错误的答案（里面很多重复）

public class Solution {
    public void solveSudoku(char[][] board) {
        if (board == null || board.length != 9 || board[0].length != 9) return;
        helper(board, 0, 0);
    }
    
    public boolean helper(char[][] board, int i, int j) {
        if (j >= 9) return helper(board, i+1, 0);
        if (i >= 9) return true;
        if (board[i][j] == '.') {
            for (int k = 1; k <= 9; k++) {
                board[i][j] = (char)('0' + k);
                if (isvalid(board, i, j)) {
                    if(helper(board, i, j+1))
                    return true;
                }
                board[i][j] = '.';
            }
        }
        else {
            return helper(board, i, j+1);
        }
        return false;
    }
    
    public boolean isvalid(char[][] board, int i, int j) {
        for (int a = 0; a < 9; a++) {
            if (a != i && board[a][j] == board[i][j]) return false;
        }
        
        for (int b = 0; b < 9; b++) {
            if (b != j && board[i][b] == board[i][j]) return false; 
        }
        
        for (int c = i/3*3; c < i/3*3 + 3; c++) {
            for (int d = j/3*3; d < j/3*3 + 3; d++) {
                if ((c != i || d != j) && board[c][d] == board[i][j]) return false;
            }
        }
        
        return true;
    }
}

在具体编程的时候，还有一个细节问题需要注意，那就是37行 （c != i || d != j）这个操作一定要用括号括起来，否则&&的操作优先级比||高，会出错