LeetCode-Sudoku Solver (递归解法)

题目地址： https://leetcode.com/problems/sudoku-solver/

// 将字符串的数独题转换成 int[9][9]
void setBoard(int board[][], char ** b, int boardRowSize, int boardColSize){
    for (int row = ; row < boardRowSize; ++row)
    for (int col = ; col < boardColSize; ++col){
        if (b[row][col] == '.')
            board[row][col] = ;
        else
            board[row][col] = b[row][col] - '';
    }
}
// 计算位置{row,col}的候选个数，并在cands返回候选列表
int calcCandNum(int board[][], int row, int col, int * cands){
    if (board[row][col] != )
        return ;// 已知位置
    int cand[] = { , , , , , , , ,  };//
    // 筛除 非法的数字
    // 按行筛除
    for (int i = ; i < ; ++i){
        if (board[row][i] != )
            cand[board[row][i] - ] = ;
    }

    // 按列
    for (int i = ; i < ; ++i){
        if (board[i][col] != )
            cand[board[i][col] - ] = ;
    }

    // 按block
    // 计算左上角坐标
    int r0, c0;
    r0 = (row / ) * ;
    c0 = (col / ) * ;
    for (int i = r0; i < r0 + ; ++i)
    for (int j = c0; j < c0 + ; ++j){
        if (board[i][j] != )
            cand[board[i][j] - ] = ;
    }
    // 剩下的1 的总和便是 候选个数
    int sum = ;
    for (int i = ; i < ; ++i){
        if (cand[i]){
            cands[sum] = i + ;
            sum++;
        }
    }
    return sum;
}

typedef struct tagCandidate{
    int row, col;           // 位置
    int n;                  // 候选个数
    int cands[];           // 候选列表
    int solved;             // 数独是否已经解开
}Candidate;

// 从数独板中返回候选个数最少的位置，其候选信息存入 cand
void getCandidate(int board[][], Candidate* cand){
    int candList[];
    int currN;
    cand->n = ;
    cand->solved = ;
    for (int row = ; row < ; ++row)
    for (int col = ; col < ; ++col){
        if (board[row][col] != ){ // 该位置有值了
            continue;
        }
        // 说明数独还有空洞
        cand->solved = ;

        // 计算该孔洞的候选个数，及候选序列
        currN = calcCandNum(board, row, col,candList);
        if (currN < cand->n){
            cand->n = currN;
            cand->row = row;
            cand->col = col;
            for (int i = ; i < currN; ++i)
                cand->cands[i] = candList[i];
        }
    }
}

int solveBoard(int board[][]){
    Candidate cand;
    getCandidate(board, &cand);
    if (cand.solved){
        return ;
    }
    for (int i = ; i < cand.n; ++i){
        // guess[cand.row][cand.col] = recursiveFlag;    // flag we guess 好像这个没什么用
        board[cand.row][cand.col] = cand.cands[i];    // fill what we guess
        if (solveBoard(board))
            // we'd solved it
            return ;
        else{
            // we'd not solved it
            // clear what we guess
            // clearGuess(int board[9][9], int guess[])
            board[cand.row][cand.col] = ;
        }
    }
    // 到这里来！！ 不可能 ， 无解？？？？
    return ;
}
// 将结果写回字符数组 b 中
void outputBoard(char **b, int board[][]){
    for(int row = ; row < ; ++row)
    for(int col = ; col < ; ++col){
        b[row][col] = '' + (board[row][col]);
    }
}
void solveSudoku(char** b, int boardRowSize, int boardColSize) {
    int board[][];
    setBoard(board, b, boardRowSize, boardColSize);
    solveBoard(board);
    outputBoard(b,board);
}