在 C 中使用递归和回溯求解数独字段

Question

My challenge is to solve a given Sudoku field with recursion and Backtracking. We already do have some code, but we do not know how to implement the Backtracking. Here is our Code:

int solve( int row, int col ) {
    if (getValueFromField(row, col) != 0) {
        if (col < 8) {
            return solve(row, col + 1);
        }
        if (col == 8) {
            return solve(row + 1, 0);
        }
        if (col == 8 && row == 8) {
            return 1;
        }
    } else {
        for (int i = 1; i <= 9; i++) {
            if (checkValueInField(i, row, col)) {
                setValueInField(i, row, col);
                if (solve(row, col)) {
                    continue;
                }
                return solve(row, col + 1);
            }
        }
        removeValueFromField(row, col);
        return 0;
    }
    return -1;
}

The methods like removeValueFromField() , setValueInField() and so on explain themselves. If not, I can explain to you what they do.

Do you have an idea on how to implement the Backtracking here? Greetings! Raffael

Answer 1

You have to save the previous checks you made eg in lists of possible values for each cell. Initially, all lists contain the numbers 1-9. Upon initialization, the lists of the given cells in the sudoku are reduced to one member.

The main algorithm then is a loop over all cells, which you might implement as recursion, like in your code. In this loop all sudoku-constrains are applied to each list, and incompatible cases are removed. Eg: Suppose cell(1,1) is '1', then we can remove 1 from all lists in row 1, column 1, block (1,1), etc. We loop until no incompatible case remains. If one of the list collapses to zero length, the sudoku is unsolveable.

If at this point (A) the length of two or more lists stays larger than 1, we choose one of the possibilities (say p) of one of those lists, and start the loop again. If this turns out to be unsolveable, we remove p from the list, step back to (A) (this is the backtracking) and try the second possibility, etc. Eventually we will reach a stage with all but one lists having length one. The sudoku is solveable, if this one last list has length > 0.

This is a simplified version which just finds one possible solution. You have to program the prototyped functions yourself.

int getListLength(row, col); // number of possible values for this cell, 0...9

void checkConstrains();         // loop all sets (rows, columns, blocks)
                                // and find lists with one element. Remove
                                // this element from all other lists in the set.
                                // Repeat until no duplicates are found.
                        
int *savelist(row, col);        // make a copy of the list
void setlist(row, col, k);      // set list of cell to { k }
getstate(), setstate(s);        // save and set state of the game, ie. all lists
                                


int solve( int row, int col ) {
        int length = getListLength(row, col);
        if(length == 0)
                return 0; // unsolveable
        
        // this is your recursion step slightly
        // reordered to avoid row-overflow
        
        if (col == 8 && row == 8) {
                return 1;
        }
        
        int next_row, next_col;
        if(col < 8) {
                next_row = row;
                next_col = col + 1;
        } else {
                next_row = row + 1;
                next_col = 0;
        }
        
        if(length == 1) {
                return solve(next_row, next_col);
        }
        
        // if we reach this step: length > 1
        checkConstrains();
        
        // length might have changed
        length = getListLength(row, col);
        
        if(length == 0)
                return 0;
        if(length == 1)
                return solve(next_row, next_col);
        
        // still: length > 1
        // backtracking stage
        
        int* list = savelist(row, col);
        sudoku s = getstate();
        
        for(int i = 0; i < length; i++) {
                setstate(s);
                setlist(row, col, list[i]);
                if(solve(row, col))
                        return 1;
        }
        // all elements from list failed-->unsolveable
        // free list and s
        return 0;
}