LeetCode-Sudoku Solver (递归解法)

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

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

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

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

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

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

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

int solveBoard(int board[9][9]){
    Candidate cand;
    getCandidate(board, &cand);
    if (cand.solved){
        return 1;
    }
    for (int i = 0; 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 1;
        else{
            // we‘d not solved it
            // clear what we guess
            // clearGuess(int board[9][9], int guess[])
            board[cand.row][cand.col] = 0;
        }
    }
    // 到这里来！！ 不可能 ， 无解？？？？
    return 0;
}
// 将结果写回字符数组 b 中
void outputBoard(char **b, int board[9][9]){
    for(int row = 0; row < 9; ++row)
    for(int col = 0; col < 9; ++col){
        b[row][col] = ‘0‘ + (board[row][col]);
    }
}
void solveSudoku(char** b, int boardRowSize, int boardColSize) {
    int board[9][9];
    setBoard(board, b, boardRowSize, boardColSize);
    solveBoard(board);
    outputBoard(b,board);
}