LeetCode35:Valid Sudoku

Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules.

The Sudoku board could be partially filled, where empty cells are filled with the character '.'.

A partially filled sudoku which is valid.

public class Solution {
    public boolean isValidSudoku(char[][] board) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int [][] table=new int[27][9];
        int [][] squareIndex = new int [][] {{0,1,2}, {3,4,5}, {6,7,8}};
        for(int i=0; i<9; i++){ // rows
            for(int j=0; j<9; j++){ // cols
                if(board[i][j]=='.')
                    continue;
                if(!Character.isDigit(board[i][j]))
                    return false;
                int val = Character.getNumericValue(board[i][j]);
                // Rows
                if(table[i][val-1]!=0)
                    return false;
                table[i][val-1]=1;
                // Columns
                if(table[j+9][val-1]!=0)
                    return false;
                table[j+9][val-1]=1;
                // Squares
                int sNdx = squareIndex[i/3][j/3];
                if(table[sNdx+18][val-1]!=0)
                    return false;
                table[sNdx+18][val-1]=1;
            }
        }
        return true;
    }
}

------------------------------------------------------------------------------------------------------------------------------------------

LL's solution:

空间是O(N)时间是O(N*sqrt(N))

public class Solution {
    public void reset(HashMap<Character,Boolean> sequence){
        sequence.put('1',false);
        sequence.put('2',false);
        sequence.put('3',false);
        sequence.put('4',false);
        sequence.put('5',false);
        sequence.put('6',false);
        sequence.put('7',false);
        sequence.put('8',false);
        sequence.put('9',false);
    }
    public boolean isValidSudoku(char[][] board) {
        // Start typing your Java solution below
        // DO NOT write main() function
        boolean res = true;
        HashMap<Character,Boolean> sequence = new HashMap<Character,Boolean>(); 
        
        //check horizon
        if(res==true){
            for(int row = 0;row<9;row++){
                if(res==true){
                    reset(sequence); 
                    for(int col = 0;col<9;col++){
                        char c = board[row][col];
                        if(c=='.')
                            continue;
                        else{
                            if(sequence.get(c)==false)
                                sequence.put(c,true);
                            else{
                                res = false;
                                break;
                            }
                        }
                    }
                }
                else
                    break;
            }
        }
        
        //check vertical
         if(res==true){
            for(int col = 0;col<9;col++){
                if(res==true){
                    reset(sequence); 
                    for(int row = 0;row<9;row++){
                        char c = board[row][col];
                        if(c=='.')
                            continue;
                        else{
                            if(sequence.get(c)==false)
                                sequence.put(c,true);
                            else{
                                res = false;
                                break;
                            }
                        }
                    }
                }
                else
                    break;
            }
        }
        
        //check square
        int row_base = 0,col_base = 0;
        if(res==true){
            while(row_base<9 || col_base<9){
                if(res == true){
                    reset(sequence);
                    for(int row = row_base;row<row_base+3;row++){
                        if(res==true){ 
                            for(int col = col_base;col<col_base+3;col++){
                                char c = board[row][col];
                                if(c=='.')
                                    continue;
                                else{
                                    if(sequence.get(c)==false)
                                        sequence.put(c,true);
                                    else{
                                        res = false;
                                        break;
                                    }
                                }
                            }
                        }//end if
                        else
                            break;
                    }//end for
                    col_base += 3;
                    if(col_base == 9 && row_base<9){
                        if(row_base!=6)
                            col_base = 0;
                        row_base += 3;
                    }
                }//end if
            }//end while
        }//end if
        
        return res;        
    }
}

Note:

记得处理最后row_base = 6,col_base = 9时，不能把col_base重新置0.

时空转换，时间O(N)，空间O(N*sqrt(N))

public class Solution {
    public boolean isValidSudoku(char[][] board) {
        // Start typing your Java solution below
        // DO NOT write main() function
        boolean res = true;
        //HashMap<Character,Boolean> sequence = new HashMap<Character,Boolean>(); 
        boolean[][] valid = new boolean[27][9];
        int horizen = 0;
        int vertical = 9;
        int square = 18;
        int index,sq_index;
        for(int row = 0; row<9; row++){
            if(res){
                for(int col = 0; col<9; col++){
                    char c = board[row][col];
                    if(c=='.')
                        continue;
                    else{
                        index = Character.getNumericValue(c)-1;
                        //check horizen
                        if(valid[horizen+row][index]==false)
                            valid[horizen+row][index]=true;
                        else{
                            res = false;
                            break;
                        }
                        //check vertical
                        if(valid[vertical+col][index]==false)
                            valid[vertical+col][index] = true;
                        else{
                            res = false;
                            break;
                        }
                        //check suqare
                        sq_index = 3*((int)row/3) + (int)col/3;
                        if(valid[square+sq_index][index]==false)
                            valid[square+sq_index][index] = true;
                        else{
                            res = false;
                            break;
                        }
                    }
                }            
            }
            else
                break;
        }
       
        return res;        
    }
}