leetcode: Sudoku Solver

DFS,回溯，AC

class Solution {
public:
    void solveSudoku(vector<vector<char> > &board) {
        solve( board);
    }
    bool isvalid( vector< vector< char> > &board, int row, int col){
        for( int i = 0; i < board.size(); ++i){
            if( i != row && board[i][col] == board[row][col])
                return false;
        }
        for( int j = 0; j < board[0].size(); ++j){
            if( j != col && board[row][j] == board[row][col])
                return false;
        }
        int blocki = row / 3;
        int blockj = col / 3;
        for( int i = blocki * 3; i < blocki * 3 + 3; ++i){
            for( int j = blockj * 3; j < blockj * 3 + 3; ++j){
                if( i != row && j != col && board[i][j] == board[row][col])
                    return false;
            }
        }
        return true;
    }
    bool solve( vector< vector< char> > &board){
        for( int i = 0; i < board.size(); ++i){
            for( int j = 0; j < board[i].size(); ++j){
                if( board[i][j] == '.'){
                    for( int k = '1'; k <= '9'; ++k){
                        board[i][j] = k;
                        if( isvalid( board, i, j) && solve( board))
                            return true;
                        board[i][j] = '.';
                    }
                    return false;
                }
            }
        }
        return true;
    }
};

直接模拟，意料之中的TLE

class Solution {
public:
    void solveSudoku(vector<vector<char> > &board) {
        generateCandidates( board, candidates);
        while( true){
            for( int i = 0; i < board.size(); ++i){
                for( int j = 0; j < board[i].size(); ++j){
                    if( candidates[i][j].size() == 1){
                        board[i][j] = *(candidates[i][j].begin());
                        if(solved( board))
                            return;
                        candidates[i][j].erase( candidates[i][j].begin());
                        generateCandidates( board, candidates);
                    }
                }
            }
        }
    }
    bool solved( vector< vector< char> > &board){
        for( int i = 0; i < board.size(); ++i)
            for( int j = 0; j < board[i].size(); ++j)
                if( board[i][j] == '.')
                    return false;
        return true;
    }
    void generateCandidates( vector< vector< char> > &board, vector< vector< set< char> > > &candidates){
        set< char> nums;
        for( int i = '1'; i <= '9'; ++i)
            nums.insert(i);
        for( int i = 0; i < 9; ++i){
            candidates.push_back( vector< set< char> >( 9, nums));
        }
        for( int i = 0; i < board.size(); ++i){
            for( int j = 0; j < board[i].size(); ++j){
                if( board[i][j] == '.'){
                    modifyCandidates( board, candidates, i, j);
                }
            }
        }
    }
    void modifyCandidates( vector< vector< char> > &board, vector< vector< set< char> > > &candidates, int row, int col){
        for( int i = 0; i < board.size(); ++i){
            if( board[i][col] != '.'){
                if( candidates[row][col].count( board[i][col]))
                    candidates[row][col].erase( board[i][col]);
            }
        }
        for( int j = 0; j < board[0].size(); ++j){
            if( board[row][j] != '.'){
                if( candidates[row][col].count( board[row][j]))
                    candidates[row][col].erase( board[row][j]);
            }
        }
        int blocki = row / 3;
        int blockj = col / 3;
        for( int i = blocki * 3; i <= blocki * 3 + 2; ++i){
            for( int j = blockj * 3; j <= blockj * 3 + 2; ++j){
                if( board[i][j] != '.'){
                    if( candidates[row][col].count( board[i][j]))
                        candidates[row][col].erase( board[i][j]);
                }
            }
        }
    }
private:
    vector< vector< set< char> > > candidates;
};