zakarya/puzzles
1
0
Fork 0
mirror of git://git.tartarus.org/simon/puzzles.git synced 2025-04-21 08:01:30 -07:00
Code Issues Packages Projects Releases Wiki Activity

Refactor latin.c to make it easier to reuse. Instead of client

Browse Source 
programs having to clone the latin_solver() function and insert
their own extra deduction routines, they can now just _call_
latin_solver with enough parameters to let it fit its own deductions
into their difficulty framework and call a set of provided function
pointers to do user deductions. Modified Unequal to work in the new
world, of course.

[originally from svn r8791]
This commit is contained in:
Simon Tatham
2009-12-27 10:01:10 +00:00
parent b9c22e5cac
commit 189f833980
3 changed files with 190 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
latin.c
View File

@ -663,11 +663,8 @@ int latin_solver_diff_set(struct latin_solver *solver,
return 0; return 0;
} }
/* This uses our own diff_* internally, but doesn't require callers /*
* to; this is so it can be used by games that want to rewrite * Returns:
* the solver so as to use a different set of difficulties.
*
* It returns:
* 0 for 'didn't do anything' implying it was already solved. * 0 for 'didn't do anything' implying it was already solved.
* -1 for 'impossible' (no solution) * -1 for 'impossible' (no solution)
* 1 for 'single solution' * 1 for 'single solution'
@ -676,8 +673,11 @@ int latin_solver_diff_set(struct latin_solver *solver,
* *
* and this function may well assert if given an impossible board. * and this function may well assert if given an impossible board.
*/ */
int latin_solver_recurse(struct latin_solver *solver, int recdiff, static int latin_solver_recurse
latin_solver_callback cb, void *ctx) (struct latin_solver *solver, int diff_simple, int diff_set_0,
int diff_set_1, int diff_forcing, int diff_recursive,
usersolver_t const *usersolvers, void *ctx,
ctxnew_t ctxnew, ctxfree_t ctxfree)
{ {
int best, bestcount; int best, bestcount;
int o = solver->o, x, y, n; int o = solver->o, x, y, n;
@ -754,6 +754,7 @@ int latin_solver_recurse(struct latin_solver *solver, int recdiff,
*/ */
for (i = 0; i < j; i++) { for (i = 0; i < j; i++) {
int ret; int ret;
void *newctx;
memcpy(outgrid, ingrid, o*o); memcpy(outgrid, ingrid, o*o);
outgrid[y*o+x] = list[i]; outgrid[y*o+x] = list[i];
@ -765,7 +766,17 @@ int latin_solver_recurse(struct latin_solver *solver, int recdiff,
solver_recurse_depth++; solver_recurse_depth++;
#endif #endif
ret = cb(outgrid, o, recdiff, ctx); if (ctxnew) {
newctx = ctxnew(ctx);
} else {
newctx = ctx;
}
ret = latin_solver(outgrid, o, diff_recursive,
diff_simple, diff_set_0, diff_set_1,
diff_forcing, diff_recursive,
usersolvers, newctx, ctxnew, ctxfree);
if (ctxnew)
ctxfree(newctx);
#ifdef STANDALONE_SOLVER #ifdef STANDALONE_SOLVER
solver_recurse_depth--; solver_recurse_depth--;
@ -793,7 +804,7 @@ int latin_solver_recurse(struct latin_solver *solver, int recdiff,
else { else {
/* the recursion turned up exactly one solution */ /* the recursion turned up exactly one solution */
if (diff == diff_impossible) if (diff == diff_impossible)
diff = recdiff; diff = diff_recursive;
else else
diff = diff_ambiguous; diff = diff_ambiguous;
} }
@ -815,15 +826,17 @@ int latin_solver_recurse(struct latin_solver *solver, int recdiff,
else if (diff == diff_ambiguous) else if (diff == diff_ambiguous)
return 2; return 2;
else { else {
assert(diff == recdiff); assert(diff == diff_recursive);
return 1; return 1;
} }
} }
} }
enum { diff_simple = 1, diff_set, diff_extreme, diff_recursive }; int latin_solver_main(struct latin_solver *solver, int maxdiff,
int diff_simple, int diff_set_0, int diff_set_1,
static int latin_solver_sub(struct latin_solver *solver, int maxdiff, void *ctx) int diff_forcing, int diff_recursive,
usersolver_t const *usersolvers, void *ctx,
ctxnew_t ctxnew, ctxfree_t ctxfree)
{ {
struct latin_solver_scratch *scratch = latin_solver_new_scratch(solver); struct latin_solver_scratch *scratch = latin_solver_new_scratch(solver);
int ret, diff = diff_simple; int ret, diff = diff_simple;
@ -837,56 +850,34 @@ static int latin_solver_sub(struct latin_solver *solver, int maxdiff, void *ctx)
* not. * not.
*/ */
while (1) { while (1) {
/* int i;
* I'd like to write `continue;' inside each of the
* following loops, so that the solver returns here after
* making some progress. However, I can't specify that I
* want to continue an outer loop rather than the innermost
* one, so I'm apologetically resorting to a goto.
*/
cont: cont:
latin_solver_debug(solver->cube, solver->o); latin_solver_debug(solver->cube, solver->o);
ret = latin_solver_diff_simple(solver); for (i = 0; i <= maxdiff; i++) {
if (ret < 0) { if (usersolvers[i])
diff = diff_impossible; ret = usersolvers[i](solver, ctx);
goto got_result; else
} else if (ret > 0) { ret = 0;
diff = max(diff, diff_simple); if (ret == 0 && i == diff_simple)
goto cont; ret = latin_solver_diff_simple(solver);
} if (ret == 0 && i == diff_set_0)
ret = latin_solver_diff_set(solver, scratch, 0);
if (ret == 0 && i == diff_set_1)
ret = latin_solver_diff_set(solver, scratch, 1);
if (ret == 0 && i == diff_forcing)
ret = latin_solver_forcing(solver, scratch);
if (maxdiff <= diff_simple) if (ret < 0) {
break; diff = diff_impossible;
goto got_result;
ret = latin_solver_diff_set(solver, scratch, 0); } else if (ret > 0) {
if (ret < 0) { diff = max(diff, i);
diff = diff_impossible; goto cont;
goto got_result; }
} else if (ret > 0) { }
diff = max(diff, diff_set);
goto cont;
}
if (maxdiff <= diff_set)
break;
ret = latin_solver_diff_set(solver, scratch, 1);
if (ret < 0) {
diff = diff_impossible;
goto got_result;
} else if (ret > 0) {
diff = max(diff, diff_extreme);
goto cont;
}
/*
* Forcing chains.
*/
if (latin_solver_forcing(solver, scratch)) {
diff = max(diff, diff_extreme);
goto cont;
}
/* /*
* If we reach here, we have made no deductions in this * If we reach here, we have made no deductions in this
@ -903,7 +894,10 @@ static int latin_solver_sub(struct latin_solver *solver, int maxdiff, void *ctx)
* possible. * possible.
*/ */
if (maxdiff == diff_recursive) { if (maxdiff == diff_recursive) {
int nsol = latin_solver_recurse(solver, diff_recursive, latin_solver, ctx); int nsol = latin_solver_recurse(solver,
diff_simple, diff_set_0, diff_set_1,
diff_forcing, diff_recursive,
usersolvers, ctx, ctxnew, ctxfree);
if (nsol < 0) diff = diff_impossible; if (nsol < 0) diff = diff_impossible;
else if (nsol == 1) diff = diff_recursive; else if (nsol == 1) diff = diff_recursive;
else if (nsol > 1) diff = diff_ambiguous; else if (nsol > 1) diff = diff_ambiguous;
@ -940,13 +934,20 @@ static int latin_solver_sub(struct latin_solver *solver, int maxdiff, void *ctx)
return diff; return diff;
} }
int latin_solver(digit *grid, int o, int maxdiff, void *ctx) int latin_solver(digit *grid, int o, int maxdiff,
int diff_simple, int diff_set_0, int diff_set_1,
int diff_forcing, int diff_recursive,
usersolver_t const *usersolvers, void *ctx,
ctxnew_t ctxnew, ctxfree_t ctxfree)
{ {
struct latin_solver solver; struct latin_solver solver;
int diff; int diff;
latin_solver_alloc(&solver, grid, o); latin_solver_alloc(&solver, grid, o);
diff = latin_solver_sub(&solver, maxdiff, ctx); diff = latin_solver_main(&solver, maxdiff,
diff_simple, diff_set_0, diff_set_1,
diff_forcing, diff_recursive,
usersolvers, ctx, ctxnew, ctxfree);
latin_solver_free(&solver); latin_solver_free(&solver);
return diff; return diff;
} }
@ -954,7 +955,7 @@ int latin_solver(digit *grid, int o, int maxdiff, void *ctx)
void latin_solver_debug(unsigned char *cube, int o) void latin_solver_debug(unsigned char *cube, int o)
{ {
#ifdef STANDALONE_SOLVER #ifdef STANDALONE_SOLVER
if (solver_show_working) { if (solver_show_working > 1) {
struct latin_solver ls, *solver = &ls; struct latin_solver ls, *solver = &ls;
char *dbg; char *dbg;
int x, y, i, c = 0; int x, y, i, c = 0;

24
latin.h
View File

@ -88,17 +88,27 @@ int latin_solver_diff_set(struct latin_solver *solver,
struct latin_solver_scratch *scratch, struct latin_solver_scratch *scratch,
int extreme); int extreme);
typedef int (latin_solver_callback)(digit *, int, int, void*); typedef int (*usersolver_t)(struct latin_solver *solver, void *ctx);
/* Use to provide a standard way of dealing with solvers which can recurse; typedef void *(*ctxnew_t)(void *ctx);
* pass in your enumeration for 'recursive diff' and your solver typedef void (*ctxfree_t)(void *ctx);
* callback. Returns #solutions (0 == already solved). */
int latin_solver_recurse(struct latin_solver *solver, int recdiff,
latin_solver_callback cb, void *ctx);
/* Individual puzzles should use their enumerations for their /* Individual puzzles should use their enumerations for their
* own difficulty levels, ensuring they don't clash with these. */ * own difficulty levels, ensuring they don't clash with these. */
enum { diff_impossible = 10, diff_ambiguous, diff_unfinished }; enum { diff_impossible = 10, diff_ambiguous, diff_unfinished };
int latin_solver(digit *grid, int order, int maxdiff, void *unused);
/* Externally callable function that allocates and frees a latin_solver */
int latin_solver(digit *grid, int o, int maxdiff,
int diff_simple, int diff_set_0, int diff_set_1,
int diff_forcing, int diff_recursive,
usersolver_t const *usersolvers, void *ctx,
ctxnew_t ctxnew, ctxfree_t ctxfree);
/* Version you can call if you want to alloc and free latin_solver yourself */
int latin_solver_main(struct latin_solver *solver, int maxdiff,
int diff_simple, int diff_set_0, int diff_set_1,
int diff_forcing, int diff_recursive,
usersolver_t const *usersolvers, void *ctx,
ctxnew_t ctxnew, ctxfree_t ctxfree);
void latin_solver_debug(unsigned char *cube, int o); void latin_solver_debug(unsigned char *cube, int o);

321
unequal.c
View File

@ -87,17 +87,17 @@ struct game_state {
*/ */
/* Steal the method from map.c for difficulty levels. */ /* Steal the method from map.c for difficulty levels. */
#define DIFFLIST(A) \ #define DIFFLIST(A) \
A(LATIN,Trivial,t) \ A(LATIN,Trivial,NULL,t) \
A(EASY,Easy,e) \ A(EASY,Easy,solver_easy, e) \
A(SET,Tricky,k) \ A(SET,Tricky,solver_set, k) \
A(EXTREME,Extreme,x) \ A(EXTREME,Extreme,NULL,x) \
A(RECURSIVE,Recursive,r) A(RECURSIVE,Recursive,NULL,r)
#define ENUM(upper,title,lower) DIFF_ ## upper, #define ENUM(upper,title,func,lower) DIFF_ ## upper,
#define TITLE(upper,title,lower) #title, #define TITLE(upper,title,func,lower) #title,
#define ENCODE(upper,title,lower) #lower #define ENCODE(upper,title,func,lower) #lower
#define CONFIG(upper,title,lower) ":" #title #define CONFIG(upper,title,func,lower) ":" #title
enum { DIFFLIST(ENUM) DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished }; enum { DIFFLIST(ENUM) DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished };
static char const *const unequal_diffnames[] = { DIFFLIST(TITLE) }; static char const *const unequal_diffnames[] = { DIFFLIST(TITLE) };
static char const unequal_diffchars[] = DIFFLIST(ENCODE); static char const unequal_diffchars[] = DIFFLIST(ENCODE);
@ -523,88 +523,75 @@ struct solver_link {
int len, gx, gy, lx, ly; int len, gx, gy, lx, ly;
}; };
typedef struct game_solver { struct solver_ctx {
struct latin_solver latin; /* keep first in struct! */
game_state *state; game_state *state;
int nlinks, alinks; int nlinks, alinks;
struct solver_link *links; struct solver_link *links;
} game_solver; };
#if 0 static void solver_add_link(struct solver_ctx *ctx,
static void solver_debug(game_solver *solver, int wide)
{
#ifdef STANDALONE_SOLVER
if (solver_show_working) {
if (!wide)
game_debug(solver->state);
else
latin_solver_debug(solver->latin.cube, solver->latin.o);
}
#endif
}
#endif
static void solver_add_link(game_solver *solver,
int gx, int gy, int lx, int ly, int len) int gx, int gy, int lx, int ly, int len)
{ {
if (solver->alinks < solver->nlinks+1) { if (ctx->alinks < ctx->nlinks+1) {
solver->alinks = solver->alinks*2 + 1; ctx->alinks = ctx->alinks*2 + 1;
/*debug(("resizing solver->links, new size %d", solver->alinks));*/ /*debug(("resizing ctx->links, new size %d", ctx->alinks));*/
solver->links = sresize(solver->links, solver->alinks, struct solver_link); ctx->links = sresize(ctx->links, ctx->alinks, struct solver_link);
} }
solver->links[solver->nlinks].gx = gx; ctx->links[ctx->nlinks].gx = gx;
solver->links[solver->nlinks].gy = gy; ctx->links[ctx->nlinks].gy = gy;
solver->links[solver->nlinks].lx = lx; ctx->links[ctx->nlinks].lx = lx;
solver->links[solver->nlinks].ly = ly; ctx->links[ctx->nlinks].ly = ly;
solver->links[solver->nlinks].len = len; ctx->links[ctx->nlinks].len = len;
solver->nlinks++; ctx->nlinks++;
/*debug(("Adding new link: len %d (%d,%d) < (%d,%d), nlinks now %d", /*debug(("Adding new link: len %d (%d,%d) < (%d,%d), nlinks now %d",
len, lx, ly, gx, gy, solver->nlinks));*/ len, lx, ly, gx, gy, ctx->nlinks));*/
} }
static game_solver *new_solver(digit *grid, game_state *state) static struct solver_ctx *new_ctx(game_state *state)
{ {
game_solver *solver = snew(game_solver); struct solver_ctx *ctx = snew(struct solver_ctx);
int o = state->order; int o = state->order;
int i, x, y; int i, x, y;
unsigned int f; unsigned int f;
latin_solver_alloc(&solver->latin, grid, o); ctx->nlinks = ctx->alinks = 0;
ctx->links = NULL;
ctx->state = state;
solver->nlinks = solver->alinks = 0; if (state->adjacent) return ctx; /* adjacent mode doesn't use links. */
solver->links = NULL;
solver->state = state;
if (state->adjacent) return solver; /* adjacent mode doesn't use links. */
for (x = 0; x < o; x++) { for (x = 0; x < o; x++) {
for (y = 0; y < o; y++) { for (y = 0; y < o; y++) {
f = GRID(state, flags, x, y); f = GRID(state, flags, x, y);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (f & adjthan[i].f) if (f & adjthan[i].f)
solver_add_link(solver, x, y, x+adjthan[i].dx, y+adjthan[i].dy, 1); solver_add_link(ctx, x, y, x+adjthan[i].dx, y+adjthan[i].dy, 1);
} }
} }
} }
return solver; return ctx;
} }
static void free_solver(game_solver *solver) static void *clone_ctx(void *vctx)
{ {
if (solver->links) sfree(solver->links); struct solver_ctx *ctx = (struct solver_ctx *)vctx;
latin_solver_free(&solver->latin); return new_ctx(ctx->state);
sfree(solver);
} }
static void solver_nminmax(game_solver *usolver, static void free_ctx(void *vctx)
{
struct solver_ctx *ctx = (struct solver_ctx *)vctx;
if (ctx->links) sfree(ctx->links);
sfree(ctx);
}
static void solver_nminmax(struct latin_solver *solver,
int x, int y, int *min_r, int *max_r, int x, int y, int *min_r, int *max_r,
unsigned char **ns_r) unsigned char **ns_r)
{ {
struct latin_solver *solver = &usolver->latin; int o = solver->o, min = o, max = 0, n;
int o = usolver->latin.o, min = o, max = 0, n;
unsigned char *ns; unsigned char *ns;
assert(x >= 0 && y >= 0 && x < o && y < o); assert(x >= 0 && y >= 0 && x < o && y < o);
@ -626,17 +613,17 @@ static void solver_nminmax(game_solver *usolver,
if (ns_r) *ns_r = ns; if (ns_r) *ns_r = ns;
} }
static int solver_links(game_solver *usolver) static int solver_links(struct latin_solver *solver, void *vctx)
{ {
struct solver_ctx *ctx = (struct solver_ctx *)vctx;
int i, j, lmin, gmax, nchanged = 0; int i, j, lmin, gmax, nchanged = 0;
unsigned char *gns, *lns; unsigned char *gns, *lns;
struct solver_link *link; struct solver_link *link;
struct latin_solver *solver = &usolver->latin;
for (i = 0; i < usolver->nlinks; i++) { for (i = 0; i < ctx->nlinks; i++) {
link = &usolver->links[i]; link = &ctx->links[i];
solver_nminmax(usolver, link->gx, link->gy, NULL, &gmax, &gns); solver_nminmax(solver, link->gx, link->gy, NULL, &gmax, &gns);
solver_nminmax(usolver, link->lx, link->ly, &lmin, NULL, &lns); solver_nminmax(solver, link->lx, link->ly, &lmin, NULL, &lns);
for (j = 0; j < solver->o; j++) { for (j = 0; j < solver->o; j++) {
/* For the 'greater' end of the link, discount all numbers /* For the 'greater' end of the link, discount all numbers
@ -680,10 +667,10 @@ static int solver_links(game_solver *usolver)
return nchanged; return nchanged;
} }
static int solver_adjacent(game_solver *usolver) static int solver_adjacent(struct latin_solver *solver, void *vctx)
{ {
struct latin_solver *solver = &usolver->latin; struct solver_ctx *ctx = (struct solver_ctx *)vctx;
int nchanged = 0, x, y, i, n, o = usolver->latin.o, nx, ny, gd; int nchanged = 0, x, y, i, n, o = solver->o, nx, ny, gd;
/* Update possible values based on known values and adjacency clues. */ /* Update possible values based on known values and adjacency clues. */
@ -695,7 +682,7 @@ static int solver_adjacent(game_solver *usolver)
* adjacent possibles reflect the adjacent/non-adjacent clue. */ * adjacent possibles reflect the adjacent/non-adjacent clue. */
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
int isadjacent = (GRID(usolver->state, flags, x, y) & adjthan[i].f); int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
nx = x + adjthan[i].dx, ny = y + adjthan[i].dy; nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
if (nx < 0 || ny < 0 || nx >= o || ny >= o) if (nx < 0 || ny < 0 || nx >= o || ny >= o)
@ -730,10 +717,10 @@ static int solver_adjacent(game_solver *usolver)
return nchanged; return nchanged;
} }
static int solver_adjacent_set(game_solver *usolver) static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
{ {
struct latin_solver *solver = &usolver->latin; struct solver_ctx *ctx = (struct solver_ctx *)vctx;
int x, y, i, n, nn, o = usolver->latin.o, nx, ny, gd; int x, y, i, n, nn, o = solver->o, nx, ny, gd;
int nchanged = 0, *scratch = snewn(o, int); int nchanged = 0, *scratch = snewn(o, int);
/* Update possible values based on other possible values /* Update possible values based on other possible values
@ -742,7 +729,7 @@ static int solver_adjacent_set(game_solver *usolver)
for (x = 0; x < o; x++) { for (x = 0; x < o; x++) {
for (y = 0; y < o; y++) { for (y = 0; y < o; y++) {
for (i = 0; i < o; i++) { for (i = 0; i < o; i++) {
int isadjacent = (GRID(usolver->state, flags, x, y) & adjthan[i].f); int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
nx = x + adjthan[i].dx, ny = y + adjthan[i].dy; nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
if (nx < 0 || ny < 0 || nx >= o || ny >= o) if (nx < 0 || ny < 0 || nx >= o || ny >= o)
@ -794,147 +781,45 @@ static int solver_adjacent_set(game_solver *usolver)
return nchanged; return nchanged;
} }
static int solver_grid(digit *grid, int o, int maxdiff, void *ctx) static int solver_easy(struct latin_solver *solver, void *vctx)
{ {
game_state *state = (game_state *)ctx; struct solver_ctx *ctx = (struct solver_ctx *)vctx;
game_solver *solver; if (ctx->state->adjacent)
struct latin_solver *lsolver; return solver_adjacent(solver, vctx);
struct latin_solver_scratch *scratch; else
int ret, diff = DIFF_LATIN; return solver_links(solver, vctx);
assert(maxdiff <= DIFF_RECURSIVE);
assert(state->order == o);
solver = new_solver(grid, state);
lsolver = &solver->latin;
scratch = latin_solver_new_scratch(lsolver);
while (1) {
cont:
ret = latin_solver_diff_simple(lsolver);
if (ret < 0) {
diff = DIFF_IMPOSSIBLE;
goto got_result;
} else if (ret > 0) {
diff = max(diff, DIFF_LATIN);
goto cont;
}
if (maxdiff <= DIFF_LATIN)
break;
if (state->adjacent) {
/* Adjacent-specific: set possibles from known numbers
* and adjacency clues. */
ret = solver_adjacent(solver);
} else {
/* Unequal-specific: set possibles from chains of
* inequalities. */
ret = solver_links(solver);
}
if (ret < 0) {
diff = DIFF_IMPOSSIBLE;
goto got_result;
} else if (ret > 0) {
diff = max(diff, DIFF_EASY);
goto cont;
}
if (maxdiff <= DIFF_EASY)
break;
/* Row- and column-wise set elimination */
ret = latin_solver_diff_set(lsolver, scratch, 0);
if (ret < 0) {
diff = DIFF_IMPOSSIBLE;
goto got_result;
} else if (ret > 0) {
diff = max(diff, DIFF_SET);
goto cont;
}
if (state->adjacent) {
/* Adjacent-specific: set possibles from other possibles
* and adjacency clues. */
ret = solver_adjacent_set(solver);
if (ret < 0) {
diff = DIFF_IMPOSSIBLE;
goto got_result;
} else if (ret > 0) {
diff = max(diff, DIFF_SET);
goto cont;
}
}
if (maxdiff <= DIFF_SET)
break;
ret = latin_solver_diff_set(lsolver, scratch, 1);
if (ret < 0) {
diff = DIFF_IMPOSSIBLE;
goto got_result;
} else if (ret > 0) {
diff = max(diff, DIFF_EXTREME);
goto cont;
}
/*
* Forcing chains.
*/
if (latin_solver_forcing(lsolver, scratch)) {
diff = max(diff, DIFF_EXTREME);
goto cont;
}
/*
* If we reach here, we have made no deductions in this
* iteration, so the algorithm terminates.
*/
break;
}
/*
* Last chance: if we haven't fully solved the puzzle yet, try
* recursing based on guesses for a particular square. We pick
* one of the most constrained empty squares we can find, which
* has the effect of pruning the search tree as much as
* possible.
*/
if (maxdiff == DIFF_RECURSIVE) {
int nsol = latin_solver_recurse(lsolver, DIFF_RECURSIVE, solver_grid, ctx);
if (nsol < 0) diff = DIFF_IMPOSSIBLE;
else if (nsol == 1) diff = DIFF_RECURSIVE;
else if (nsol > 1) diff = DIFF_AMBIGUOUS;
/* if nsol == 0 then we were complete anyway
* (and thus don't need to change diff) */
} else {
int cc = check_complete(grid, state, 0);
if (cc == -1) diff = DIFF_IMPOSSIBLE;
if (cc == 0) diff = DIFF_UNFINISHED;
}
got_result:
#ifdef STANDALONE_SOLVER
if (solver_show_working)
printf("%*s%s found\n",
solver_recurse_depth*4, "",
diff == DIFF_IMPOSSIBLE ? "no solution (impossible)" :
diff == DIFF_UNFINISHED ? "no solution (unfinished)" :
diff == DIFF_AMBIGUOUS ? "multiple solutions" :
"one solution");
#endif
latin_solver_free_scratch(scratch);
memcpy(state->hints, solver->latin.cube, o*o*o);
free_solver(solver);
return diff;
} }
static int solver_set(struct latin_solver *solver, void *vctx)
{
struct solver_ctx *ctx = (struct solver_ctx *)vctx;
if (ctx->state->adjacent)
return solver_adjacent_set(solver, vctx);
else
return 0;
}
#define SOLVER(upper,title,func,lower) func,
static usersolver_t const unequal_solvers[] = { DIFFLIST(SOLVER) };
static int solver_state(game_state *state, int maxdiff) static int solver_state(game_state *state, int maxdiff)
{ {
int diff = solver_grid(state->nums, state->order, maxdiff, (void*)state); struct solver_ctx *ctx = new_ctx(state);
struct latin_solver solver;
int diff;
latin_solver_alloc(&solver, state->nums, state->order);
diff = latin_solver_main(&solver, maxdiff,
DIFF_LATIN, DIFF_SET, DIFF_EXTREME,
DIFF_EXTREME, DIFF_RECURSIVE,
unequal_solvers, ctx, clone_ctx, free_ctx);
memcpy(state->hints, solver.cube, state->order*state->order*state->order);
free_ctx(ctx);
latin_solver_free(&solver);
if (diff == DIFF_IMPOSSIBLE) if (diff == DIFF_IMPOSSIBLE)
return -1; return -1;
@ -2126,17 +2011,29 @@ static void pdiff(int diff)
static int solve(game_params *p, char *desc, int debug) static int solve(game_params *p, char *desc, int debug)
{ {
game_state *st = new_game(NULL, p, desc); game_state *state = new_game(NULL, p, desc);
struct solver_ctx *ctx = new_ctx(state);
struct latin_solver solver;
int diff; int diff;
solver_show_working = debug; solver_show_working = debug;
game_debug(st); game_debug(state);
latin_solver_alloc(&solver, state->nums, state->order);
diff = latin_solver_main(&solver, DIFF_RECURSIVE,
DIFF_LATIN, DIFF_SET, DIFF_EXTREME,
DIFF_EXTREME, DIFF_RECURSIVE,
unequal_solvers, ctx, clone_ctx, free_ctx);
free_ctx(ctx);
latin_solver_free(&solver);
diff = solver_grid(st->nums, st->order, DIFF_RECURSIVE, (void*)st);
if (debug) pdiff(diff); if (debug) pdiff(diff);
game_debug(st); game_debug(state);
free_game(st); free_game(state);
return diff; return diff;
} }