Valid Sudoku and Sudoku Solver leetcode

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.

Note:
A valid Sudoku board (partially filled) is not necessarily solvable. Only the filled cells need to be validated.

数独：满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复 。独盘面是个九宫，每一宫又分为九个小格

注意到题目中说的,只要当前已经填充的数字是合法的就可以,不一定要这个数独是有解.（下面说的九宫格都是指3*3的网格）

因此只需要判断9*9网格的每一行、每一列、9个小九宫格是否合法。即如果在每一行、每一列、每个9个小九宫格内，某个数字重复出现了，当前数独就是不合法的。 

如果把九宫格按照行从0开始标号，那么数字board[i][j] 位于第 i/3*3+j/3 个九宫格内

• 在检测行是否合法时，i 表示矩阵的行，j 表示矩阵的列；
• 检测列是否合法时，i 表示矩阵的列，j 表示矩阵的行；
• 检测九宫格是否合法时，i 表示九宫格的标号，j 表示九宫格里的每个元素（只是我们需要根据i、j定位相应的元素到原来的矩阵：第 i 个九宫格里面的第 j 个元素在原矩阵的第 3*(i/3) + j/3 行，第 3*(i%3) + j%3）列，“/” 表示整数除法）

class Solution {
public:
    bool isValidSudoku(vector<vector<char> > &board) {
        int rowValid[10] = {0};
        int colValid[10] = {0};
        int subBoardValid[10] = {0};
        for(int i=0;i<9;i++) {
            memset(rowValid,0,sizeof(rowValid));
            memset(colValid,0,sizeof(colValid));
            memset(subBoardValid,0,sizeof(subBoardValid));
            for(int j=0;j<9;j++) {
                if(!isValid(rowValid,board[i][j]) || !isValid(colValid,board[j][i]) || !isValid(subBoardValid,board[3*(i/3)+j/3][3*(i%3)+j%3])) {
                    return false;
                }
            }
        }
        return true;
    }
    bool isValid(int arr[],char index) {
        if(index == '.')
        return true;
        if(arr[index-'0'] == 1)
        return false;
        arr[index-'0'] = 1;
        return true;
    }
};

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.

A sudoku puzzle...

...and its solution numbers marked in red.

这种类型的游戏一般回溯法来解决，设置某个空格时，如果该空格无论设置什么数字都无法达到合法状态，那么回溯重新设置上一个空格

class Solution {
public:
    void solveSudoku(vector<vector<char> > &board) {
        solve(board,0);
    }
    bool solve(vector<vector<char> > &board,int index) {
        if(index>80)
        return true;
        int i=index/9;
        int j= index-i*9;
        if(board[i][j] != '.')
        return solve(board,index+1);
        for(int k=1;k<=9;k++) {
            board[i][j] = '0' + k;
            if(isValid(board,i,j) && solve(board,index+1))
            return true;
            board[i][j] = '.';
        }
        return false;
         
    }
    bool isValid(vector<vector<char> > &board,int i, int j) {
        for(int m=0;m<9;m++) {
            if(m!=i && board[m][j] == board[i][j])
            return false;
        }
        for(int n=0;n<9;n++) {
            if(n!=j && board[i][n] == board[i][j])
            return false;
        }
        for(int m=3*(i/3);m<3*(i/3+1);m++) {
            for(int n=3*(j/3);n<3*(j/3+1);n++) {
                if(m!=i && n!=j && board[m][n] == board[i][j])
                return false;
            }
        }
        return true;
    }
};