Implement metadata-based board solving
This commit is contained in:
parent
83e2d0f3e3
commit
d8f12f1262
37
board.c
37
board.c
@ -75,7 +75,14 @@ meta_init (struct metadata *meta)
|
||||
void
|
||||
board_init (struct board *board)
|
||||
{
|
||||
memset (board, 0, sizeof board->elements);
|
||||
struct board_element defval;
|
||||
defval.has_value = false;
|
||||
defval.potential = 0x1FF;
|
||||
defval.complexity = 9;
|
||||
|
||||
for (size_t t = 0; t < (sizeof (board->elements) / sizeof (struct board_element)); ++t)
|
||||
memcpy (&board->elements[t], &defval, sizeof (struct board_element));
|
||||
|
||||
board->complexity = 9;
|
||||
|
||||
for (unsigned i = 0; i < 9; ++i)
|
||||
@ -129,7 +136,7 @@ meta_mark (struct metadata *meta, element_value value, unsigned index)
|
||||
void
|
||||
board_meta_quad_refresh (struct board *board, board_pos qx, board_pos qy)
|
||||
{
|
||||
struct metadata *meta = BOARD_QUAD (board, qx, qy);
|
||||
struct metadata *meta = BOARD_QUAD (board, qx * 3, qy * 3);
|
||||
board_pos quad_base_x = qx * 3;
|
||||
board_pos quad_base_y = qy * 3;
|
||||
|
||||
@ -194,7 +201,7 @@ board_meta_can_set (
|
||||
return ! (
|
||||
meta_has_value (BOARD_ROW (board, y), value) ||
|
||||
meta_has_value (BOARD_COL (board, x), value) ||
|
||||
meta_has_value (BOARD_QUAD (board, TO_QUAD (x), TO_QUAD (y)), value)
|
||||
meta_has_value (BOARD_QUAD (board, x, y), value)
|
||||
);
|
||||
}
|
||||
else ERROR("Invalid parameters to function board_meta_can_set()");
|
||||
@ -310,7 +317,7 @@ board_get_value (
|
||||
|
||||
bool
|
||||
board_is_marked (
|
||||
struct board *board,
|
||||
const struct board *board,
|
||||
board_pos x,
|
||||
board_pos y,
|
||||
element_value value
|
||||
@ -330,13 +337,8 @@ board_is_valid (struct board *board)
|
||||
for (board_pos y = 0; y < 9; ++y)
|
||||
for (board_pos x = 0; x < 9; ++x)
|
||||
if (
|
||||
board_has_value (board, x, y) &&
|
||||
! board_meta_can_set (
|
||||
board,
|
||||
x,
|
||||
y,
|
||||
BOARD_ELEM (board, x, y)->value
|
||||
)
|
||||
!board_has_value (board, x, y) &&
|
||||
BOARD_ELEM (board, x, y)->potential == 0
|
||||
)
|
||||
return false;
|
||||
return true;
|
||||
@ -359,7 +361,7 @@ board_update_marks (
|
||||
elem->complexity = 0;
|
||||
|
||||
/* Check x-axis */
|
||||
elem->potential |= BOARD_QUAD (board, TO_QUAD (x), TO_QUAD (y))->marked;
|
||||
elem->potential |= BOARD_QUAD (board, x, y)->marked;
|
||||
elem->potential |= BOARD_ROW (board, y)->marked;
|
||||
elem->potential |= BOARD_COL (board, x)->marked;
|
||||
|
||||
@ -813,15 +815,16 @@ board_place (
|
||||
}
|
||||
|
||||
/* Update metadata */
|
||||
meta_set_value (BOARD_QUAD (board, quad_x, quad_y), value);
|
||||
meta_set_value (BOARD_QUAD (board, x, y), value);
|
||||
meta_set_value (BOARD_ROW (board, y), value);
|
||||
meta_set_value (BOARD_COL (board, x), value);
|
||||
|
||||
/* Set value */
|
||||
board_set (board, x, y, value);
|
||||
|
||||
return true;
|
||||
/* Update board complexity */
|
||||
return board_refresh_complexity (board);
|
||||
//return board_refresh_complexity (board);
|
||||
}
|
||||
else return false;
|
||||
}
|
||||
@ -846,9 +849,11 @@ board_place_speculative (
|
||||
/* Create duplicate and place value */
|
||||
board_copy (board, board_duplicate);
|
||||
|
||||
if (! board_place (board_duplicate, x, y, value))
|
||||
if (! board_place (board_duplicate, x, y, value) || ! board_is_valid (board_duplicate))
|
||||
return NULL;
|
||||
|
||||
board_refresh_complexity (board_duplicate);
|
||||
|
||||
return board_duplicate;
|
||||
}
|
||||
else return NULL;
|
||||
@ -860,7 +865,7 @@ board_place_speculative (
|
||||
bool
|
||||
board_refresh_complexity (struct board *board)
|
||||
{
|
||||
board_update_all_marks (board);
|
||||
//board_update_all_marks (board);
|
||||
|
||||
board->complexity = 10;
|
||||
for (board_pos y = 0; y < 9; ++y)
|
||||
|
||||
6
board.h
6
board.h
@ -14,7 +14,7 @@
|
||||
/**
|
||||
* Get a `struct metadata`-entry from a specified location on the quadrand grid
|
||||
*/
|
||||
#define BOARD_QUAD(board_ptr, qx, qy) (&(board_ptr)->meta_quad[(qy) * 3 + (qx)])
|
||||
#define BOARD_QUAD(board_ptr, x, y) (&(board_ptr)->meta_quad[TO_QUAD ((y)) + ((x) / 3)])
|
||||
|
||||
/**
|
||||
* Get a `struct metadata`-entry from a specified row value
|
||||
@ -74,7 +74,7 @@ struct metadata {
|
||||
struct board {
|
||||
/* Immediate data*/
|
||||
struct board_element elements[81]; /* Game board */
|
||||
unsigned char complexity : 3; /* Complexity of simplest element */
|
||||
unsigned char complexity : 4; /* Complexity of simplest element */
|
||||
|
||||
/* Metadata */
|
||||
struct metadata meta_quad [9]; /* Quadrant metadata */
|
||||
@ -224,7 +224,7 @@ board_get_value (
|
||||
*/
|
||||
bool
|
||||
board_is_marked (
|
||||
struct board *board,
|
||||
const struct board *board,
|
||||
board_pos x,
|
||||
board_pos y,
|
||||
element_value value
|
||||
|
||||
230
main.c
230
main.c
@ -30,6 +30,14 @@
|
||||
#define DEPTH_INCREMENT 3
|
||||
|
||||
|
||||
|
||||
struct args {
|
||||
bool valid;
|
||||
unsigned verbosity : 2;
|
||||
char *file_name;
|
||||
};
|
||||
|
||||
|
||||
struct boards_table {
|
||||
struct board **board_specs;
|
||||
unsigned long long max_depth;
|
||||
@ -66,11 +74,9 @@ tables_ensure_depth (struct boards_table *board_spec, unsigned long long depth)
|
||||
bool
|
||||
simplify (
|
||||
struct boards_table *board_spec,
|
||||
unsigned long long depth
|
||||
#ifdef PRINT_STATUS
|
||||
,
|
||||
unsigned long long *counter
|
||||
#endif
|
||||
unsigned long long depth,
|
||||
unsigned long long *counter,
|
||||
unsigned verbosity
|
||||
);
|
||||
|
||||
|
||||
@ -163,7 +169,7 @@ copy_to_board (struct board_file file, struct board *board)
|
||||
board_pos y = i / 10;
|
||||
|
||||
if (data[i - 1] != ' ')
|
||||
board_set (board, x - 1, y, data[i - 1] - '0' - 1);
|
||||
board_place (board, x - 1, y, data[i - 1] - '0' - 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -191,6 +197,50 @@ ansi_cursor_show (bool show)
|
||||
fputs("\e[?25l", stdout);
|
||||
}
|
||||
|
||||
static void
|
||||
print_board_verbose (
|
||||
const struct board *board,
|
||||
unsigned whence_x,
|
||||
unsigned whence_y
|
||||
)
|
||||
{
|
||||
for (board_pos y = 0; y < 9; ++y)
|
||||
{
|
||||
for (board_pos x = 0; x < 9; ++x)
|
||||
{
|
||||
for (element_value vy = 0; vy < 3; ++vy)
|
||||
for (element_value vx = 0; vx < 3; ++vx)
|
||||
{
|
||||
element_value check = vx + (vy * 3);
|
||||
|
||||
ansi_set_cursor (whence_x + (x * 4) + vx, whence_y + (y * 4) + vy);
|
||||
|
||||
if (board_has_value (board, x, y))
|
||||
printf ("%u", board_get_value (board, x, y) + 1);
|
||||
else if (board_is_marked (board, x, y, check))
|
||||
printf (COLOUR_RED "%u" COLOUR_RESET, check + 1);
|
||||
else
|
||||
fputs (" ", stdout);
|
||||
|
||||
if (vx == 2 && x != 8)
|
||||
fputs ("|", stdout);
|
||||
}
|
||||
}
|
||||
|
||||
ansi_set_cursor (0, (y * 4) + 3);
|
||||
if (y != 8)
|
||||
{
|
||||
for (unsigned i = 0; i < (4 * 9) - 1; ++i)
|
||||
if ((i + 1) % 4 == 0)
|
||||
fputs ("+", stdout);
|
||||
else
|
||||
fputs ("-", stdout);
|
||||
}
|
||||
}
|
||||
|
||||
fflush (stdout);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
print_board (const struct board *board, const struct board *compare, unsigned whence_x, unsigned whence_y)
|
||||
@ -252,7 +302,7 @@ first_potential_value (struct board_element *element, struct board *board, bool
|
||||
element_value value = 0;
|
||||
while (potential != 0)
|
||||
{
|
||||
if (potential & 1 == 1)
|
||||
if ((potential & 1) == 1)
|
||||
return value;
|
||||
++value;
|
||||
potential >>= 1;
|
||||
@ -269,37 +319,33 @@ first_potential_value (struct board_element *element, struct board *board, bool
|
||||
bool
|
||||
simplify (
|
||||
struct boards_table *board_specs,
|
||||
unsigned long long depth
|
||||
#ifdef PRINT_STATUS
|
||||
,
|
||||
unsigned long long *counter
|
||||
#endif
|
||||
unsigned long long depth,
|
||||
unsigned long long *counter,
|
||||
unsigned verbosity
|
||||
)
|
||||
{
|
||||
#ifdef PRINT_STATUS
|
||||
if (((*counter) & PRINT_STATUS) == 0) {
|
||||
ansi_set_cursor (0, 18);
|
||||
printf ("Reducing... (%lx)", *counter);
|
||||
}
|
||||
|
||||
if (((*counter) & PRINT_STATUS) == 0)
|
||||
print_board (board_specs->board_specs[depth], board_specs->board_specs[0], 21, 0);
|
||||
|
||||
*counter += 1;
|
||||
#endif
|
||||
|
||||
/* Get current table */
|
||||
struct board *board = board_specs->board_specs[depth];
|
||||
|
||||
if (verbosity > 0)
|
||||
{
|
||||
if ((*counter) & (0xFFFF >> (4 * (4 - verbosity))))
|
||||
{
|
||||
print_board_verbose (board, 0, 0);
|
||||
ansi_set_cursor (0, 35);
|
||||
printf ("Iteration: %lu", *counter);
|
||||
}
|
||||
*counter += 1;
|
||||
}
|
||||
|
||||
|
||||
bool error;
|
||||
|
||||
bool placed = false;
|
||||
unsigned count = 0;
|
||||
|
||||
/* Reduce using low-complexity computation */
|
||||
while (board->complexity == 1)
|
||||
{
|
||||
placed = false;
|
||||
for (board_pos y = 0; y < 9; ++y)
|
||||
for (board_pos x = 0; x < 9; ++x)
|
||||
if (! board_has_value (board, x, y))
|
||||
@ -310,19 +356,21 @@ simplify (
|
||||
element_value value = first_potential_value (elem, board, &error);
|
||||
if (error) return false;
|
||||
|
||||
placed = true;
|
||||
++count;
|
||||
|
||||
//fprintf (stderr, "Placing (%u, %u)=%u (potential=%u)\n", x, y, value, elem->potential);
|
||||
|
||||
if (! board_place (board, x, y, value))
|
||||
break;
|
||||
{
|
||||
bool rerr = meta_has_value (BOARD_ROW (board, y), value);
|
||||
bool cerr = meta_has_value (BOARD_COL (board, x), value);
|
||||
bool qerr = meta_has_value (BOARD_QUAD (board, TO_QUAD (x), TO_QUAD (y)), value);
|
||||
fprintf (stderr, "Error (%u, %u, %u)\n", rerr, cerr, qerr);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (! placed)
|
||||
{
|
||||
print_board (board_specs->board_specs[depth], board_specs->board_specs[0], 21, 0);
|
||||
printf ("Count: %u\n", count);
|
||||
abort ();
|
||||
}
|
||||
|
||||
board_refresh_complexity (board);
|
||||
}
|
||||
|
||||
/* Attempt to reduce with speculative placement */
|
||||
@ -332,7 +380,7 @@ simplify (
|
||||
for (board_pos x = 0; x < 9; ++x)
|
||||
{
|
||||
struct board_element *elem = BOARD_ELEM (board, x, y);
|
||||
/* Find a simplest element on the board*/
|
||||
/* Find a simplest element on the board */
|
||||
if (
|
||||
! board_has_value (board, x, y) &&
|
||||
elem->complexity == board->complexity
|
||||
@ -354,24 +402,27 @@ simplify (
|
||||
|
||||
/* If speculative placement failed, try another value */
|
||||
if (board_spec == NULL)
|
||||
{
|
||||
board_unmark (board, x, y, value);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Found solution */
|
||||
if (
|
||||
simplify (
|
||||
board_specs,
|
||||
depth + 1
|
||||
#ifdef PRINT_STATUS
|
||||
,
|
||||
counter
|
||||
#endif
|
||||
) && board_spec->complexity == 0)
|
||||
depth + 1,
|
||||
counter,
|
||||
verbosity
|
||||
) &&
|
||||
board_spec->complexity == 0)
|
||||
{
|
||||
board_copy (board_spec, board);
|
||||
x = 9;
|
||||
y = 9;
|
||||
value = 9;
|
||||
}
|
||||
else board_unmark (board, x, y, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -380,18 +431,66 @@ simplify (
|
||||
}
|
||||
|
||||
|
||||
struct args
|
||||
argparse (int argc, char **argv)
|
||||
{
|
||||
struct args result;
|
||||
result.file_name = NULL;
|
||||
result.valid = true;
|
||||
result.verbosity = 0;
|
||||
if (argc < 2)
|
||||
{
|
||||
result.valid = false;
|
||||
return result;
|
||||
}
|
||||
|
||||
for (int i = 1; i < argc; ++i)
|
||||
if (strncmp (argv[i], "-", 1) == 0)
|
||||
{
|
||||
if (result.verbosity != 0)
|
||||
{
|
||||
result.valid = false;
|
||||
return result;
|
||||
}
|
||||
if (strcmp (argv[i], "-v") == 0)
|
||||
result.verbosity = 1;
|
||||
else if (strcmp (argv[i], "-vv") == 0)
|
||||
result.verbosity = 2;
|
||||
else
|
||||
{
|
||||
result.valid = false;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
else if (result.file_name == NULL)
|
||||
result.file_name = argv[i];
|
||||
else
|
||||
{
|
||||
result.valid = false;
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int
|
||||
main (int argc, char **argv, char **env)
|
||||
{
|
||||
if (argc != 2) return -1;
|
||||
struct args args = argparse (argc, argv);
|
||||
if (! args.valid)
|
||||
{
|
||||
fputs ("Badly formatted arguments! Usage:\n\t./sudoku [-v[v]] {file name}\n", stderr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct board_file file = load_board_file (argv[1]);
|
||||
struct board_file file = load_board_file (args.file_name);
|
||||
if (file.fd == -1 || file.data == NULL)
|
||||
return -1;
|
||||
|
||||
ansi_cursor_show (false);
|
||||
|
||||
/* Allocate board */
|
||||
/* Allocate boards */
|
||||
struct board original;
|
||||
|
||||
struct boards_table boards;
|
||||
@ -406,47 +505,52 @@ main (int argc, char **argv, char **env)
|
||||
|
||||
close_board_file (file);
|
||||
|
||||
board_update_all_marks (root_board);
|
||||
|
||||
|
||||
|
||||
ansi_clear_screen ();
|
||||
|
||||
print_board (root_board, NULL, 0, 0);
|
||||
|
||||
|
||||
if (! board_is_valid (root_board))
|
||||
{
|
||||
puts ("Supplied board is not valid!");
|
||||
fputs ("Supplied board is not valid!\n", stderr);
|
||||
|
||||
ansi_cursor_show (true);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
ansi_set_cursor (0, 18);
|
||||
puts("Reducing...");
|
||||
if (args.verbosity == 0)
|
||||
puts ("Simplifying...");
|
||||
|
||||
|
||||
board_refresh_complexity (root_board);
|
||||
|
||||
/* Profiler start time */
|
||||
clock_t start_clk = clock ();
|
||||
|
||||
#ifdef PRINT_STATUS
|
||||
unsigned long long counter = 0;
|
||||
|
||||
simplify (&boards, 0, &counter);
|
||||
|
||||
#else
|
||||
|
||||
simplify (&boards, 0);
|
||||
|
||||
#endif
|
||||
simplify (&boards, 0, &counter, args.verbosity);
|
||||
|
||||
/* Profiler end time */
|
||||
clock_t end_clk = clock ();
|
||||
|
||||
print_board (root_board, &original, 21, 0);
|
||||
|
||||
ansi_set_cursor (0, 18);
|
||||
ansi_clear_screen ();
|
||||
|
||||
if (root_board->complexity == 0)
|
||||
{
|
||||
print_board (&original, NULL, 0, 0);
|
||||
print_board (root_board, &original, 21, 0);
|
||||
ansi_set_cursor (0, 18);
|
||||
}
|
||||
else
|
||||
{
|
||||
print_board_verbose (root_board, 0, 0);
|
||||
ansi_set_cursor (0, 36);
|
||||
}
|
||||
printf ("Simplification took %Lf seconds\n", ((long double)(end_clk - start_clk))/CLOCKS_PER_SEC);
|
||||
|
||||
|
||||
ansi_cursor_show (true);
|
||||
|
||||
return 0;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user