ref: a0c7156fc8547fd0d6591413dea01462d003b847
dir: /latin.c/
#include <assert.h> #include <string.h> #include <stdarg.h> #include "puzzles.h" #include "tree234.h" #include "matching.h" #ifdef STANDALONE_LATIN_TEST #define STANDALONE_SOLVER #endif #include "latin.h" /* -------------------------------------------------------- * Solver. */ static int latin_solver_top(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, validator_t valid, void *ctx, ctxnew_t ctxnew, ctxfree_t ctxfree); #ifdef STANDALONE_SOLVER int solver_show_working, solver_recurse_depth; #endif /* * Function called when we are certain that a particular square has * a particular number in it. The y-coordinate passed in here is * transformed. */ void latin_solver_place(struct latin_solver *solver, int x, int y, int n) { int i, o = solver->o; assert(n <= o); assert(cube(x,y,n)); /* * Rule out all other numbers in this square. */ for (i = 1; i <= o; i++) if (i != n) cube(x,y,i) = false; /* * Rule out this number in all other positions in the row. */ for (i = 0; i < o; i++) if (i != y) cube(x,i,n) = false; /* * Rule out this number in all other positions in the column. */ for (i = 0; i < o; i++) if (i != x) cube(i,y,n) = false; /* * Enter the number in the result grid. */ solver->grid[y*o+x] = n; /* * Cross out this number from the list of numbers left to place * in its row, its column and its block. */ solver->row[y*o+n-1] = solver->col[x*o+n-1] = true; } int latin_solver_elim(struct latin_solver *solver, int start, int step #ifdef STANDALONE_SOLVER , const char *fmt, ... #endif ) { int o = solver->o; #ifdef STANDALONE_SOLVER char **names = solver->names; #endif int fpos, m, i; /* * Count the number of set bits within this section of the * cube. */ m = 0; fpos = -1; for (i = 0; i < o; i++) if (solver->cube[start+i*step]) { fpos = start+i*step; m++; } if (m == 1) { int x, y, n; assert(fpos >= 0); n = 1 + fpos % o; y = fpos / o; x = y / o; y %= o; if (!solver->grid[y*o+x]) { #ifdef STANDALONE_SOLVER if (solver_show_working) { va_list ap; printf("%*s", solver_recurse_depth*4, ""); va_start(ap, fmt); vprintf(fmt, ap); va_end(ap); printf(":\n%*s placing %s at (%d,%d)\n", solver_recurse_depth*4, "", names[n-1], x+1, y+1); } #endif latin_solver_place(solver, x, y, n); return +1; } } else if (m == 0) { #ifdef STANDALONE_SOLVER if (solver_show_working) { va_list ap; printf("%*s", solver_recurse_depth*4, ""); va_start(ap, fmt); vprintf(fmt, ap); va_end(ap); printf(":\n%*s no possibilities available\n", solver_recurse_depth*4, ""); } #endif return -1; } return 0; } struct latin_solver_scratch { unsigned char *grid, *rowidx, *colidx, *set; int *neighbours, *bfsqueue; #ifdef STANDALONE_SOLVER int *bfsprev; #endif }; int latin_solver_set(struct latin_solver *solver, struct latin_solver_scratch *scratch, int start, int step1, int step2 #ifdef STANDALONE_SOLVER , const char *fmt, ... #endif ) { int o = solver->o; #ifdef STANDALONE_SOLVER char **names = solver->names; #endif int i, j, n, count; unsigned char *grid = scratch->grid; unsigned char *rowidx = scratch->rowidx; unsigned char *colidx = scratch->colidx; unsigned char *set = scratch->set; /* * We are passed a o-by-o matrix of booleans. Our first job * is to winnow it by finding any definite placements - i.e. * any row with a solitary 1 - and discarding that row and the * column containing the 1. */ memset(rowidx, true, o); memset(colidx, true, o); for (i = 0; i < o; i++) { int count = 0, first = -1; for (j = 0; j < o; j++) if (solver->cube[start+i*step1+j*step2]) first = j, count++; if (count == 0) return -1; if (count == 1) rowidx[i] = colidx[first] = false; } /* * Convert each of rowidx/colidx from a list of 0s and 1s to a * list of the indices of the 1s. */ for (i = j = 0; i < o; i++) if (rowidx[i]) rowidx[j++] = i; n = j; for (i = j = 0; i < o; i++) if (colidx[i]) colidx[j++] = i; assert(n == j); /* * And create the smaller matrix. */ for (i = 0; i < n; i++) for (j = 0; j < n; j++) grid[i*o+j] = solver->cube[start+rowidx[i]*step1+colidx[j]*step2]; /* * Having done that, we now have a matrix in which every row * has at least two 1s in. Now we search to see if we can find * a rectangle of zeroes (in the set-theoretic sense of * `rectangle', i.e. a subset of rows crossed with a subset of * columns) whose width and height add up to n. */ memset(set, 0, n); count = 0; while (1) { /* * We have a candidate set. If its size is <=1 or >=n-1 * then we move on immediately. */ if (count > 1 && count < n-1) { /* * The number of rows we need is n-count. See if we can * find that many rows which each have a zero in all * the positions listed in `set'. */ int rows = 0; for (i = 0; i < n; i++) { bool ok = true; for (j = 0; j < n; j++) if (set[j] && grid[i*o+j]) { ok = false; break; } if (ok) rows++; } /* * We expect never to be able to get _more_ than * n-count suitable rows: this would imply that (for * example) there are four numbers which between them * have at most three possible positions, and hence it * indicates a faulty deduction before this point or * even a bogus clue. */ if (rows > n - count) { #ifdef STANDALONE_SOLVER if (solver_show_working) { va_list ap; printf("%*s", solver_recurse_depth*4, ""); va_start(ap, fmt); vprintf(fmt, ap); va_end(ap); printf(":\n%*s contradiction reached\n", solver_recurse_depth*4, ""); } #endif return -1; } if (rows >= n - count) { bool progress = false; /* * We've got one! Now, for each row which _doesn't_ * satisfy the criterion, eliminate all its set * bits in the positions _not_ listed in `set'. * Return +1 (meaning progress has been made) if we * successfully eliminated anything at all. * * This involves referring back through * rowidx/colidx in order to work out which actual * positions in the cube to meddle with. */ for (i = 0; i < n; i++) { bool ok = true; for (j = 0; j < n; j++) if (set[j] && grid[i*o+j]) { ok = false; break; } if (!ok) { for (j = 0; j < n; j++) if (!set[j] && grid[i*o+j]) { int fpos = (start+rowidx[i]*step1+ colidx[j]*step2); #ifdef STANDALONE_SOLVER if (solver_show_working) { int px, py, pn; if (!progress) { va_list ap; printf("%*s", solver_recurse_depth*4, ""); va_start(ap, fmt); vprintf(fmt, ap); va_end(ap); printf(":\n"); } pn = 1 + fpos % o; py = fpos / o; px = py / o; py %= o; printf("%*s ruling out %s at (%d,%d)\n", solver_recurse_depth*4, "", names[pn-1], px+1, py+1); } #endif progress = true; solver->cube[fpos] = false; } } } if (progress) { return +1; } } } /* * Binary increment: change the rightmost 0 to a 1, and * change all 1s to the right of it to 0s. */ i = n; while (i > 0 && set[i-1]) set[--i] = 0, count--; if (i > 0) set[--i] = 1, count++; else break; /* done */ } return 0; } /* * Look for forcing chains. A forcing chain is a path of * pairwise-exclusive squares (i.e. each pair of adjacent squares * in the path are in the same row, column or block) with the * following properties: * * (a) Each square on the path has precisely two possible numbers. * * (b) Each pair of squares which are adjacent on the path share * at least one possible number in common. * * (c) Each square in the middle of the path shares _both_ of its * numbers with at least one of its neighbours (not the same * one with both neighbours). * * These together imply that at least one of the possible number * choices at one end of the path forces _all_ the rest of the * numbers along the path. In order to make real use of this, we * need further properties: * * (c) Ruling out some number N from the square at one end * of the path forces the square at the other end to * take number N. * * (d) The two end squares are both in line with some third * square. * * (e) That third square currently has N as a possibility. * * If we can find all of that lot, we can deduce that at least one * of the two ends of the forcing chain has number N, and that * therefore the mutually adjacent third square does not. * * To find forcing chains, we're going to start a bfs at each * suitable square, once for each of its two possible numbers. */ int latin_solver_forcing(struct latin_solver *solver, struct latin_solver_scratch *scratch) { int o = solver->o; #ifdef STANDALONE_SOLVER char **names = solver->names; #endif int *bfsqueue = scratch->bfsqueue; #ifdef STANDALONE_SOLVER int *bfsprev = scratch->bfsprev; #endif unsigned char *number = scratch->grid; int *neighbours = scratch->neighbours; int x, y; for (y = 0; y < o; y++) for (x = 0; x < o; x++) { int count, t, n; /* * If this square doesn't have exactly two candidate * numbers, don't try it. * * In this loop we also sum the candidate numbers, * which is a nasty hack to allow us to quickly find * `the other one' (since we will shortly know there * are exactly two). */ for (count = t = 0, n = 1; n <= o; n++) if (cube(x, y, n)) count++, t += n; if (count != 2) continue; /* * Now attempt a bfs for each candidate. */ for (n = 1; n <= o; n++) if (cube(x, y, n)) { int orign, currn, head, tail; /* * Begin a bfs. */ orign = n; memset(number, o+1, o*o); head = tail = 0; bfsqueue[tail++] = y*o+x; #ifdef STANDALONE_SOLVER bfsprev[y*o+x] = -1; #endif number[y*o+x] = t - n; while (head < tail) { int xx, yy, nneighbours, xt, yt, i; xx = bfsqueue[head++]; yy = xx / o; xx %= o; currn = number[yy*o+xx]; /* * Find neighbours of yy,xx. */ nneighbours = 0; for (yt = 0; yt < o; yt++) neighbours[nneighbours++] = yt*o+xx; for (xt = 0; xt < o; xt++) neighbours[nneighbours++] = yy*o+xt; /* * Try visiting each of those neighbours. */ for (i = 0; i < nneighbours; i++) { int cc, tt, nn; xt = neighbours[i] % o; yt = neighbours[i] / o; /* * We need this square to not be * already visited, and to include * currn as a possible number. */ if (number[yt*o+xt] <= o) continue; if (!cube(xt, yt, currn)) continue; /* * Don't visit _this_ square a second * time! */ if (xt == xx && yt == yy) continue; /* * To continue with the bfs, we need * this square to have exactly two * possible numbers. */ for (cc = tt = 0, nn = 1; nn <= o; nn++) if (cube(xt, yt, nn)) cc++, tt += nn; if (cc == 2) { bfsqueue[tail++] = yt*o+xt; #ifdef STANDALONE_SOLVER bfsprev[yt*o+xt] = yy*o+xx; #endif number[yt*o+xt] = tt - currn; } /* * One other possibility is that this * might be the square in which we can * make a real deduction: if it's * adjacent to x,y, and currn is equal * to the original number we ruled out. */ if (currn == orign && (xt == x || yt == y)) { #ifdef STANDALONE_SOLVER if (solver_show_working) { const char *sep = ""; int xl, yl; printf("%*sforcing chain, %s at ends of ", solver_recurse_depth*4, "", names[orign-1]); xl = xx; yl = yy; while (1) { printf("%s(%d,%d)", sep, xl+1, yl+1); xl = bfsprev[yl*o+xl]; if (xl < 0) break; yl = xl / o; xl %= o; sep = "-"; } printf("\n%*s ruling out %s at (%d,%d)\n", solver_recurse_depth*4, "", names[orign-1], xt+1, yt+1); } #endif cube(xt, yt, orign) = false; return 1; } } } } } return 0; } struct latin_solver_scratch *latin_solver_new_scratch(struct latin_solver *solver) { struct latin_solver_scratch *scratch = snew(struct latin_solver_scratch); int o = solver->o; scratch->grid = snewn(o*o, unsigned char); scratch->rowidx = snewn(o, unsigned char); scratch->colidx = snewn(o, unsigned char); scratch->set = snewn(o, unsigned char); scratch->neighbours = snewn(3*o, int); scratch->bfsqueue = snewn(o*o, int); #ifdef STANDALONE_SOLVER scratch->bfsprev = snewn(o*o, int); #endif return scratch; } void latin_solver_free_scratch(struct latin_solver_scratch *scratch) { #ifdef STANDALONE_SOLVER sfree(scratch->bfsprev); #endif sfree(scratch->bfsqueue); sfree(scratch->neighbours); sfree(scratch->set); sfree(scratch->colidx); sfree(scratch->rowidx); sfree(scratch->grid); sfree(scratch); } bool latin_solver_alloc(struct latin_solver *solver, digit *grid, int o) { int x, y; solver->o = o; solver->cube = snewn(o*o*o, unsigned char); solver->grid = grid; /* write straight back to the input */ memset(solver->cube, 1, o*o*o); solver->row = snewn(o*o, unsigned char); solver->col = snewn(o*o, unsigned char); memset(solver->row, 0, o*o); memset(solver->col, 0, o*o); #ifdef STANDALONE_SOLVER solver->names = NULL; #endif for (x = 0; x < o; x++) { for (y = 0; y < o; y++) { int n = grid[y*o+x]; if (n) { if (cube(x, y, n)) latin_solver_place(solver, x, y, n); else return false; /* puzzle is already inconsistent */ } } } return true; } void latin_solver_free(struct latin_solver *solver) { sfree(solver->cube); sfree(solver->row); sfree(solver->col); } int latin_solver_diff_simple(struct latin_solver *solver) { int x, y, n, ret, o = solver->o; #ifdef STANDALONE_SOLVER char **names = solver->names; #endif /* * Row-wise positional elimination. */ for (y = 0; y < o; y++) for (n = 1; n <= o; n++) if (!solver->row[y*o+n-1]) { ret = latin_solver_elim(solver, cubepos(0,y,n), o*o #ifdef STANDALONE_SOLVER , "positional elimination," " %s in row %d", names[n-1], y+1 #endif ); if (ret != 0) return ret; } /* * Column-wise positional elimination. */ for (x = 0; x < o; x++) for (n = 1; n <= o; n++) if (!solver->col[x*o+n-1]) { ret = latin_solver_elim(solver, cubepos(x,0,n), o #ifdef STANDALONE_SOLVER , "positional elimination," " %s in column %d", names[n-1], x+1 #endif ); if (ret != 0) return ret; } /* * Numeric elimination. */ for (x = 0; x < o; x++) for (y = 0; y < o; y++) if (!solver->grid[y*o+x]) { ret = latin_solver_elim(solver, cubepos(x,y,1), 1 #ifdef STANDALONE_SOLVER , "numeric elimination at (%d,%d)", x+1, y+1 #endif ); if (ret != 0) return ret; } return 0; } int latin_solver_diff_set(struct latin_solver *solver, struct latin_solver_scratch *scratch, bool extreme) { int x, y, n, ret, o = solver->o; #ifdef STANDALONE_SOLVER char **names = solver->names; #endif if (!extreme) { /* * Row-wise set elimination. */ for (y = 0; y < o; y++) { ret = latin_solver_set(solver, scratch, cubepos(0,y,1), o*o, 1 #ifdef STANDALONE_SOLVER , "set elimination, row %d", y+1 #endif ); if (ret != 0) return ret; } /* * Column-wise set elimination. */ for (x = 0; x < o; x++) { ret = latin_solver_set(solver, scratch, cubepos(x,0,1), o, 1 #ifdef STANDALONE_SOLVER , "set elimination, column %d", x+1 #endif ); if (ret != 0) return ret; } } else { /* * Row-vs-column set elimination on a single number * (much tricker for a human to do!) */ for (n = 1; n <= o; n++) { ret = latin_solver_set(solver, scratch, cubepos(0,0,n), o*o, o #ifdef STANDALONE_SOLVER , "positional set elimination on %s", names[n-1] #endif ); if (ret != 0) return ret; } } return 0; } /* * Returns: * 0 for 'didn't do anything' implying it was already solved. * -1 for 'impossible' (no solution) * 1 for 'single solution' * >1 for 'multiple solutions' (you don't get to know how many, and * the first such solution found will be set. * * and this function may well assert if given an impossible board. */ static int latin_solver_recurse (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, validator_t valid, void *ctx, ctxnew_t ctxnew, ctxfree_t ctxfree) { int best, bestcount; int o = solver->o, x, y, n; #ifdef STANDALONE_SOLVER char **names = solver->names; #endif best = -1; bestcount = o+1; for (y = 0; y < o; y++) for (x = 0; x < o; x++) if (!solver->grid[y*o+x]) { int count; /* * An unfilled square. Count the number of * possible digits in it. */ count = 0; for (n = 1; n <= o; n++) if (cube(x,y,n)) count++; /* * We should have found any impossibilities * already, so this can safely be an assert. */ assert(count > 1); if (count < bestcount) { bestcount = count; best = y*o+x; } } if (best == -1) /* we were complete already. */ return 0; else { int i, j; digit *list, *ingrid, *outgrid; int diff = diff_impossible; /* no solution found yet */ /* * Attempt recursion. */ y = best / o; x = best % o; list = snewn(o, digit); ingrid = snewn(o*o, digit); outgrid = snewn(o*o, digit); memcpy(ingrid, solver->grid, o*o); /* Make a list of the possible digits. */ for (j = 0, n = 1; n <= o; n++) if (cube(x,y,n)) list[j++] = n; #ifdef STANDALONE_SOLVER if (solver_show_working) { const char *sep = ""; printf("%*srecursing on (%d,%d) [", solver_recurse_depth*4, "", x+1, y+1); for (i = 0; i < j; i++) { printf("%s%s", sep, names[list[i]-1]); sep = " or "; } printf("]\n"); } #endif /* * And step along the list, recursing back into the * main solver at every stage. */ for (i = 0; i < j; i++) { int ret; void *newctx; struct latin_solver subsolver; memcpy(outgrid, ingrid, o*o); outgrid[y*o+x] = list[i]; #ifdef STANDALONE_SOLVER if (solver_show_working) printf("%*sguessing %s at (%d,%d)\n", solver_recurse_depth*4, "", names[list[i]-1], x+1, y+1); solver_recurse_depth++; #endif if (ctxnew) { newctx = ctxnew(ctx); } else { newctx = ctx; } #ifdef STANDALONE_SOLVER subsolver.names = solver->names; #endif if (latin_solver_alloc(&subsolver, outgrid, o)) ret = latin_solver_top(&subsolver, diff_recursive, diff_simple, diff_set_0, diff_set_1, diff_forcing, diff_recursive, usersolvers, valid, newctx, ctxnew, ctxfree); else ret = diff_impossible; latin_solver_free(&subsolver); if (ctxnew) ctxfree(newctx); #ifdef STANDALONE_SOLVER solver_recurse_depth--; if (solver_show_working) { printf("%*sretracting %s at (%d,%d)\n", solver_recurse_depth*4, "", names[list[i]-1], x+1, y+1); } #endif /* we recurse as deep as we can, so we should never find * find ourselves giving up on a puzzle without declaring it * impossible. */ assert(ret != diff_unfinished); /* * If we have our first solution, copy it into the * grid we will return. */ if (diff == diff_impossible && ret != diff_impossible) memcpy(solver->grid, outgrid, o*o); if (ret == diff_ambiguous) diff = diff_ambiguous; else if (ret == diff_impossible) /* do not change our return value */; else { /* the recursion turned up exactly one solution */ if (diff == diff_impossible) diff = diff_recursive; else diff = diff_ambiguous; } /* * As soon as we've found more than one solution, * give up immediately. */ if (diff == diff_ambiguous) break; } sfree(outgrid); sfree(ingrid); sfree(list); if (diff == diff_impossible) return -1; else if (diff == diff_ambiguous) return 2; else { assert(diff == diff_recursive); return 1; } } } static int latin_solver_top(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, validator_t valid, void *ctx, ctxnew_t ctxnew, ctxfree_t ctxfree) { struct latin_solver_scratch *scratch = latin_solver_new_scratch(solver); int ret, diff = diff_simple; assert(maxdiff <= diff_recursive); /* * Now loop over the grid repeatedly trying all permitted modes * of reasoning. The loop terminates if we complete an * iteration without making any progress; we then return * failure or success depending on whether the grid is full or * not. */ while (1) { int i; cont: latin_solver_debug(solver->cube, solver->o); for (i = 0; i <= maxdiff; i++) { if (usersolvers[i]) ret = usersolvers[i](solver, ctx); else ret = 0; if (ret == 0 && i == diff_simple) ret = latin_solver_diff_simple(solver); if (ret == 0 && i == diff_set_0) ret = latin_solver_diff_set(solver, scratch, false); if (ret == 0 && i == diff_set_1) ret = latin_solver_diff_set(solver, scratch, true); if (ret == 0 && i == diff_forcing) ret = latin_solver_forcing(solver, scratch); if (ret < 0) { diff = diff_impossible; goto got_result; } else if (ret > 0) { diff = max(diff, i); 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(solver, diff_simple, diff_set_0, diff_set_1, diff_forcing, diff_recursive, usersolvers, valid, ctx, ctxnew, ctxfree); 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 { /* * We're forbidden to use recursion, so we just see whether * our grid is fully solved, and return diff_unfinished * otherwise. */ int x, y, o = solver->o; for (y = 0; y < o; y++) for (x = 0; x < o; x++) if (!solver->grid[y*o+x]) diff = diff_unfinished; } got_result: #ifdef STANDALONE_SOLVER if (solver_show_working) { if (diff != diff_impossible && diff != diff_unfinished && diff != diff_ambiguous) { int x, y; printf("%*sone solution found:\n", solver_recurse_depth*4, ""); for (y = 0; y < solver->o; y++) { printf("%*s", solver_recurse_depth*4+1, ""); for (x = 0; x < solver->o; x++) { int val = solver->grid[y*solver->o+x]; assert(val); printf(" %s", solver->names[val-1]); } printf("\n"); } } else { printf("%*s%s found\n", solver_recurse_depth*4, "", diff == diff_impossible ? "no solution (impossible)" : diff == diff_unfinished ? "no solution (unfinished)" : "multiple solutions"); } } #endif if (diff != diff_impossible && diff != diff_unfinished && diff != diff_ambiguous && valid && !valid(solver, ctx)) { #ifdef STANDALONE_SOLVER if (solver_show_working) { printf("%*ssolution failed final validation!\n", solver_recurse_depth*4, ""); } #endif diff = diff_impossible; } latin_solver_free_scratch(scratch); return diff; } 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, validator_t valid, void *ctx, ctxnew_t ctxnew, ctxfree_t ctxfree) { int diff; #ifdef STANDALONE_SOLVER int o = solver->o; char *text = NULL, **names = NULL; #endif #ifdef STANDALONE_SOLVER if (!solver->names) { char *p; int i; text = snewn(40 * o, char); p = text; solver->names = snewn(o, char *); for (i = 0; i < o; i++) { solver->names[i] = p; p += 1 + sprintf(p, "%d", i+1); } } #endif diff = latin_solver_top(solver, maxdiff, diff_simple, diff_set_0, diff_set_1, diff_forcing, diff_recursive, usersolvers, valid, ctx, ctxnew, ctxfree); #ifdef STANDALONE_SOLVER sfree(names); sfree(text); #endif return diff; } 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, validator_t valid, void *ctx, ctxnew_t ctxnew, ctxfree_t ctxfree) { struct latin_solver solver; int diff; if (latin_solver_alloc(&solver, grid, o)) diff = latin_solver_main(&solver, maxdiff, diff_simple, diff_set_0, diff_set_1, diff_forcing, diff_recursive, usersolvers, valid, ctx, ctxnew, ctxfree); else diff = diff_impossible; latin_solver_free(&solver); return diff; } void latin_solver_debug(unsigned char *cube, int o) { #ifdef STANDALONE_SOLVER if (solver_show_working > 1) { struct latin_solver ls, *solver = &ls; char *dbg; int x, y, i, c = 0; ls.cube = cube; ls.o = o; /* for cube() to work */ dbg = snewn(3*o*o*o, char); for (y = 0; y < o; y++) { for (x = 0; x < o; x++) { for (i = 1; i <= o; i++) { if (cube(x,y,i)) dbg[c++] = i + '0'; else dbg[c++] = '.'; } dbg[c++] = ' '; } dbg[c++] = '\n'; } dbg[c++] = '\n'; dbg[c++] = '\0'; printf("%s", dbg); sfree(dbg); } #endif } void latin_debug(digit *sq, int o) { #ifdef STANDALONE_SOLVER if (solver_show_working) { int x, y; for (y = 0; y < o; y++) { for (x = 0; x < o; x++) { printf("%2d ", sq[y*o+x]); } printf("\n"); } printf("\n"); } #endif } /* -------------------------------------------------------- * Generation. */ digit *latin_generate(int o, random_state *rs) { digit *sq; int *adjdata, *adjsizes, *matching; int **adjlists; void *scratch; int i, j, k; digit *row; /* * To efficiently generate a latin square in such a way that * all possible squares are possible outputs from the function, * we make use of a theorem which states that any r x n latin * rectangle, with r < n, can be extended into an (r+1) x n * latin rectangle. In other words, we can reliably generate a * latin square row by row, by at every stage writing down any * row at all which doesn't conflict with previous rows, and * the theorem guarantees that we will never have to backtrack. * * To find a viable row at each stage, we can make use of the * support functions in matching.c. */ sq = snewn(o*o, digit); /* * matching.c will take care of randomising the generation of each * row of the square, but in case this entire method of generation * introduces a really subtle top-to-bottom directional bias, * we'll also generate the rows themselves in random order. */ row = snewn(o, digit); for (i = 0; i < o; i++) row[i] = i; shuffle(row, i, sizeof(*row), rs); /* * Set up the infrastructure for the matching subroutine. */ scratch = smalloc(matching_scratch_size(o, o)); adjdata = snewn(o*o, int); adjlists = snewn(o, int *); adjsizes = snewn(o, int); matching = snewn(o, int); /* * Now generate each row of the latin square. */ for (i = 0; i < o; i++) { /* * Make adjacency lists for a bipartite graph joining each * column to all the numbers not yet placed in that column. */ for (j = 0; j < o; j++) { int *p, *adj = adjdata + j*o; for (k = 0; k < o; k++) adj[k] = 1; for (k = 0; k < i; k++) adj[sq[row[k]*o + j] - 1] = 0; adjlists[j] = p = adj; for (k = 0; k < o; k++) if (adj[k]) *p++ = k; adjsizes[j] = p - adjlists[j]; } /* * Run the matching algorithm. */ j = matching_with_scratch(scratch, o, o, adjlists, adjsizes, rs, matching, NULL); assert(j == o); /* by the above theorem, this must have succeeded */ /* * And use the output to set up the new row of the latin * square. */ for (j = 0; j < o; j++) sq[row[i]*o + j] = matching[j] + 1; } /* * Done. Free our internal workspaces... */ sfree(matching); sfree(adjlists); sfree(adjsizes); sfree(adjdata); sfree(scratch); sfree(row); /* * ... and return our completed latin square. */ return sq; } digit *latin_generate_rect(int w, int h, random_state *rs) { int o = max(w, h), x, y; digit *latin, *latin_rect; latin = latin_generate(o, rs); latin_rect = snewn(w*h, digit); for (x = 0; x < w; x++) { for (y = 0; y < h; y++) { latin_rect[y*w + x] = latin[y*o + x]; } } sfree(latin); return latin_rect; } /* -------------------------------------------------------- * Checking. */ typedef struct lcparams { digit elt; int count; } lcparams; static int latin_check_cmp(void *v1, void *v2) { lcparams *lc1 = (lcparams *)v1; lcparams *lc2 = (lcparams *)v2; if (lc1->elt < lc2->elt) return -1; if (lc1->elt > lc2->elt) return 1; return 0; } #define ELT(sq,x,y) (sq[((y)*order)+(x)]) /* returns true if sq is not a latin square. */ bool latin_check(digit *sq, int order) { tree234 *dict = newtree234(latin_check_cmp); int c, r; bool ret = false; lcparams *lcp, lc, *aret; /* Use a tree234 as a simple hash table, go through the square * adding elements as we go or incrementing their counts. */ for (c = 0; c < order; c++) { for (r = 0; r < order; r++) { lc.elt = ELT(sq, c, r); lc.count = 0; lcp = find234(dict, &lc, NULL); if (!lcp) { lcp = snew(lcparams); lcp->elt = ELT(sq, c, r); lcp->count = 1; aret = add234(dict, lcp); assert(aret == lcp); } else { lcp->count++; } } } /* There should be precisely 'order' letters in the alphabet, * each occurring 'order' times (making the OxO tree) */ if (count234(dict) != order) ret = true; else { for (c = 0; (lcp = index234(dict, c)) != NULL; c++) { if (lcp->count != order) ret = true; } } for (c = 0; (lcp = index234(dict, c)) != NULL; c++) sfree(lcp); freetree234(dict); return ret; } /* vim: set shiftwidth=4 tabstop=8: */