Leetcode | Valid Sudoku & Sudoku Solver

判断valid，没有更好的方法，只能brute force。

class Solution {
public:
    bool isValidSudoku(vector<vector<char> > &board) {
        
        int n;
        for (int i = 0; i < 9; ++i) {
            vector<bool> contained(9, false);
            for (int j = 0; j < 9; ++j) {
                if (board[i][j] == '.') continue;
                n = board[i][j] - '0' - 1;
                if (contained[n]) return false;
                contained[n] = true;
            }
        }
        
        for (int i = 0; i < 9; ++i) {
            vector<bool> contained(9, false);
            for (int j = 0; j < 9; ++j) {
                if (board[j][i] == '.') continue;
                n = board[j][i] - '0' - 1;
                if (contained[n]) return false;
                contained[n] = true;
            }
        }
        
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                vector<bool> contained(9, false);
                for (int k = 0; k < 3; ++k) {
                    for (int m = 0; m < 3; ++m) {
                        if (board[i*3+k][j*3+m] == '.') continue;
                        n = board[i*3+k][j*3+m] - '0' - 1;
                        if (contained[n]) return false;
                        contained[n] = true;
                    }
                }
            }
        }
        return true;
    }
};

求解决方案也只有backtrack。

class Solution {
public:
    void solveSudoku(vector<vector<char> > &board) {
        list<int> unsolved;
        getUnsolved(board, unsolved);
        recursive(board, unsolved);
    }
    
    bool recursive(vector<vector<char> > &board, list<int> &unsolved) {
        if (unsolved.empty()) return true;
        int loc = unsolved.front();
        int row = loc / 9;
        int col = loc % 9;
        
        vector<bool> contained(9, false);
        int n;
        for (int i = 0; i < 9; ++i) {
            if (board[row][i] != '.') {
                contained[board[row][i] - '0' - 1] = true;
            }
            if (board[i][col] != '.') {
                contained[board[i][col] - '0' - 1] = true;
            }
        }
        
        row = row / 3; col = col / 3;
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                if (board[row * 3 + i][col * 3 + j] != '.') {
                    contained[board[row * 3 + i][col * 3 + j] - '0' - 1] = true;
                }
            }
        }
        
        row = loc / 9; col = loc % 9;
        for (int i = 0; i < 9; ++i) {
            if (!contained[i]) {
                board[row][col] = i + 1 + '0'; 
                unsolved.pop_front();
                if (recursive(board, unsolved)) return true;
                board[row][col] = '.';
                unsolved.push_front(loc);
            }
        }
        
        return false;
    }
    
    void getUnsolved(vector<vector<char> > &board, list<int> &unsolved) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; ++j) {
                if (board[i][j] == '.') {
                    unsolved.push_back(i * 9 + j);
                }
            }
        }
    }
};

用unsolved数组可以避免每次都需要从头扫到尾去找下一个元素。

用contained数组先保存了在该行该格该九宫格里已经存在的数字。这样就可以直接去试验剩下的数字，而不需要每次都再检查一遍插入的值是否合法。

backtrack是一个要有返回值，否则都不知道你backtrack到头了没，是否找到解决方案了。