Sudoku Solver

Write a program to solve a Sudoku puzzle by filling the empty cells.
A sudoku solution must satisfy all of the following rules:

1. Each of the digits 1-9 must occur exactly once in each row.
2. Each of the digits 1-9 must occur exactly once in each column.
3. Each of the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.
4. Empty cells are indicated by the character ‘.’.

Analysis

Given a 9*9 table, solve for Sudoku. With the back-depth depth-first search algorithm, the focus is on searching from left to right, and jumping to the next line at the end of the line. First give the template pseudo code of DFS

/**
 * DFS core pseudo code
   * The precondition is that the visit array is all set to false
   * @param n node where the current search starts
   * @param d the current depth of arrival
   * @return Is there a solution?
 */
bool DFS(Node n, int d){
	 If (isEnd(n, d)){//true if the search depth reaches an end state
		return true;
	}
 
	 For (Node nextNode in n){// traversing n adjacent nodes nextNode
		if (!visit[nextNode]){//
			 Visit[nextNode] = true;//nextNode cannot appear again in the next search
			 If (DFS(nextNode, d+1)){//If the search has a solution
				 //Do something else, such as recording the depth of the results, etc.
				return true;
			}
 
			 / / Reset to false, because it may appear in the other path of the next search
			visit[nextNode] = false;
		}
	}
	 Return false; / / this search has no solution
}

The code of the question

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

reference

https://leetcode.com/problems/sudoku-solver/discuss/15853/Simple-and-Clean-Solution-C%2B%2B