std::size_t solve_board(list_type const& list, std::size_t size,
std::size_t level, std::size_t col)
{
board b(list, size, level);
if(level == size){
return 1;
}
else if(level == 0)
{
b.update_board(level, col);
if(b.check_board( b.access_board(), level))
{
b.count_+= solve_board( b.access_board(),
size, level + 1, col);
}
}
else
{
for(std::size_t i = 0; i < size; ++i)
{
b.update_board(level,i);
if(b.check_board( b.access_board(), level))
{
b.count_+= solve_board( b.access_board(),
size, level+1, col);
}
}
}
return b.count_;
}
void solve_board(board_t* board)
{
stats.solve++;
if (is_complete(board)) {
printf("SOLVED!\n");
print_board(board);
print_stats(stats);
assert(0);
} else if (is_dead_end(board)) {
debugf("dead end, skip\n");
} else {
size_t i_row, i_col;
digits_t digits;
find_next_continuation(board, &i_row, &i_col, &digits);
debugf("best continuation [%lu,%lu]\n", i_row, i_col);
size_t i;
for (i = 1; i < NDIGITS; i++) {
if (0 == digits.digits[i]) {
debugf("extending [%lu,%lu] <- %lu\n", i_row, i_col, i);
board_t* new_board = copy_board(board);
set_digit(new_board, i_row, i_col, i);
solve_board(new_board);
free(new_board);
}
}
}
}
int main(int argc, const char **argv) {
if (argc != 2)
return usage();
read_board(argv[1]);
solve_board();
print_board();
return 0;
}
int main() // int argc, char* argv)
{
init_stats(&stats);
board_t* board = new_board();
if (false == load_board(board)) {
printf("bad board\n");
} else {
printf("loaded board:\n");
print_board(board);
solve_board(board);
}
// print_board(board);
return 0;
}
int solve_board() {
// find the x and y to try
int x, y;
// see if the board has an empty space and set the x and y
int empty = 0;
for (x = 0; x < SIZE; x++) {
for (y = 0; y < SIZE; y++) {
if (board[x][y] == EMPTY) {
empty = 1;
break;
}
}
if (empty == 1) break;
}
if (empty == 0) return 1;
// track numbers already used in row and cols
int numbers[SIZE + 1] = { 0 };
for (int i = 0; i < SIZE; i++) {
numbers[board[x][i]] = 1;
numbers[board[i][y]] = 1;
}
// track numbers already used in the unit
int ux = (x / 3) * 3;
int uy = (y / 3) * 3;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
numbers[board[ux + i][uy + j]] = 1;
// find unused numbers and see if they fit
for (int i = 1; i <= SIZE; i++) {
// find an available number
if (numbers[i] == 0) {
// see if it works
board[x][y] = i;
if (solve_board() == 1)
return 1;
// otherwise reset and try the next number
board[x][y] = EMPTY;
}
}
return 0;
}
/*
* Solves a board starting with the given cell. Returns 1 if the board could be
* solved, 0 if not.
*/
int solve_board(struct board *b, int r, int c)
{
int prev;
int val;
assert_(b != NULL &&
r >= MIN_NUM && r <= MAX_NUM &&
c >= MIN_NUM && c <= MAX_NUM);
/* Base case: board solved, print it. */
if (b->unset_cells == 0) {
print_board(b);
return 1;
}
/* Find the next unset cell. */
while (is_set(b, r, c) && next_cell(&r, &c))
;
/* This should never happen. */
if (is_set(b, r, c))
return 1;
/* Try every possible cell value until the board can be solved. */
prev = MIN_NUM;
while (1) {
val = find_common_free(b->cells[r][c].row_candidates,
b->cells[r][c].col_candidates,
b->cells[r][c].square_candidates,
prev);
if (val == -1)
break;
set_cell(b, r, c, val);
if (solve_board(b, r, c))
return 1;
unset_cell(b, r, c, val);
prev = val+1;
}
return 0;
}
int main(int argc, char *argv[])
{
FILE *in;
struct board b;
int ret;
if (argc > 2) {
fprintf(stderr, "ERROR: too many arguments\n");
return 1;
}
if (argc == 2) {
in = fopen(argv[1], "r");
if (in == NULL) {
fprintf(stderr, "ERROR: could not open \"%s\"\n", argv[1]);
return 2;
}
} else {
in = stdin;
}
/* Initialize data structures. */
init_board(&b);
/* Read and solve board. */
read_board(in, &b);
ret = solve_board(&b, MIN_NUM, MIN_NUM);
/* Close input and return. */
fclose(in);
if (! ret)
fprintf(stderr, "ERROR: board could not be solved\n");
return (ret?0:3);
}
static void sudoku_solve(void)
{
completed=1;
solve_board();
sudoku_draw_board();
}
