ref: e8cdac58e551f5c4444a6ff293eaad8e4923856e
dir: /laydomino.c/
/*
* laydomino.c: code for performing a domino (2x1 tile) layout of
* a given area of code.
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "puzzles.h"
/*
* This function returns an array size w x h representing a grid:
* each grid[i] = j, where j is the other end of a 2x1 domino.
* If w*h is odd, one square will remain referring to itself.
*/
int *domino_layout(int w, int h, random_state *rs)
{
int *grid, *grid2, *list;
int wh = w*h;
/*
* Allocate space in which to lay the grid out.
*/
grid = snewn(wh, int);
grid2 = snewn(wh, int);
list = snewn(2*wh, int);
domino_layout_prealloc(w, h, rs, grid, grid2, list);
sfree(grid2);
sfree(list);
return grid;
}
/*
* As for domino_layout, but with preallocated buffers.
* grid and grid2 should be size w*h, and list size 2*w*h.
*/
void domino_layout_prealloc(int w, int h, random_state *rs,
int *grid, int *grid2, int *list)
{
int i, j, k, m, wh = w*h, todo, done;
/*
* To begin with, set grid[i] = i for all i to indicate
* that all squares are currently singletons. Later we'll
* set grid[i] to be the index of the other end of the
* domino on i.
*/
for (i = 0; i < wh; i++)
grid[i] = i;
/*
* Now prepare a list of the possible domino locations. There
* are w*(h-1) possible vertical locations, and (w-1)*h
* horizontal ones, for a total of 2*wh - h - w.
*
* I'm going to denote the vertical domino placement with
* its top in square i as 2*i, and the horizontal one with
* its left half in square i as 2*i+1.
*/
k = 0;
for (j = 0; j < h-1; j++)
for (i = 0; i < w; i++)
list[k++] = 2 * (j*w+i); /* vertical positions */
for (j = 0; j < h; j++)
for (i = 0; i < w-1; i++)
list[k++] = 2 * (j*w+i) + 1; /* horizontal positions */
assert(k == 2*wh - h - w);
/*
* Shuffle the list.
*/
shuffle(list, k, sizeof(*list), rs);
/*
* Work down the shuffled list, placing a domino everywhere
* we can.
*/
for (i = 0; i < k; i++) {
int horiz, xy, xy2;
horiz = list[i] % 2;
xy = list[i] / 2;
xy2 = xy + (horiz ? 1 : w);
if (grid[xy] == xy && grid[xy2] == xy2) {
/*
* We can place this domino. Do so.
*/
grid[xy] = xy2;
grid[xy2] = xy;
}
}
#ifdef GENERATION_DIAGNOSTICS
printf("generated initial layout\n");
#endif
/*
* Now we've placed as many dominoes as we can immediately
* manage. There will be squares remaining, but they'll be
* singletons. So loop round and deal with the singletons
* two by two.
*/
while (1) {
#ifdef GENERATION_DIAGNOSTICS
for (j = 0; j < h; j++) {
for (i = 0; i < w; i++) {
int xy = j*w+i;
int v = grid[xy];
int c = (v == xy+1 ? '[' : v == xy-1 ? ']' :
v == xy+w ? 'n' : v == xy-w ? 'U' : '.');
putchar(c);
}
putchar('\n');
}
putchar('\n');
#endif
/*
* Our strategy is:
*
* First find a singleton square.
*
* Then breadth-first search out from the starting
* square. From that square (and any others we reach on
* the way), examine all four neighbours of the square.
* If one is an end of a domino, we move to the _other_
* end of that domino before looking at neighbours
* again. When we encounter another singleton on this
* search, stop.
*
* This will give us a path of adjacent squares such
* that all but the two ends are covered in dominoes.
* So we can now shuffle every domino on the path up by
* one.
*
* (Chessboard colours are mathematically important
* here: we always end up pairing each singleton with a
* singleton of the other colour. However, we never
* have to track this manually, since it's
* automatically taken care of by the fact that we
* always make an even number of orthogonal moves.)
*/
k = 0;
for (j = 0; j < wh; j++) {
if (grid[j] == j) {
k++;
i = j; /* start BFS here. */
}
}
if (k == (wh % 2))
break; /* if area is even, we have no more singletons;
if area is odd, we have one singleton.
either way, we're done. */
#ifdef GENERATION_DIAGNOSTICS
printf("starting b.f.s. at singleton %d\n", i);
#endif
/*
* Set grid2 to -1 everywhere. It will hold our
* distance-from-start values, and also our
* backtracking data, during the b.f.s.
*/
for (j = 0; j < wh; j++)
grid2[j] = -1;
grid2[i] = 0; /* starting square has distance zero */
/*
* Start our to-do list of squares. It'll live in
* `list'; since the b.f.s can cover every square at
* most once there is no need for it to be circular.
* We'll just have two counters tracking the end of the
* list and the squares we've already dealt with.
*/
done = 0;
todo = 1;
list[0] = i;
/*
* Now begin the b.f.s. loop.
*/
while (done < todo) {
int d[4], nd, x, y;
i = list[done++];
#ifdef GENERATION_DIAGNOSTICS
printf("b.f.s. iteration from %d\n", i);
#endif
x = i % w;
y = i / w;
nd = 0;
if (x > 0)
d[nd++] = i - 1;
if (x+1 < w)
d[nd++] = i + 1;
if (y > 0)
d[nd++] = i - w;
if (y+1 < h)
d[nd++] = i + w;
/*
* To avoid directional bias, process the
* neighbours of this square in a random order.
*/
shuffle(d, nd, sizeof(*d), rs);
for (j = 0; j < nd; j++) {
k = d[j];
if (grid[k] == k) {
#ifdef GENERATION_DIAGNOSTICS
printf("found neighbouring singleton %d\n", k);
#endif
grid2[k] = i;
break; /* found a target singleton! */
}
/*
* We're moving through a domino here, so we
* have two entries in grid2 to fill with
* useful data. In grid[k] - the square
* adjacent to where we came from - I'm going
* to put the address _of_ the square we came
* from. In the other end of the domino - the
* square from which we will continue the
* search - I'm going to put the distance.
*/
m = grid[k];
if (grid2[m] < 0 || grid2[m] > grid2[i]+1) {
#ifdef GENERATION_DIAGNOSTICS
printf("found neighbouring domino %d/%d\n", k, m);
#endif
grid2[m] = grid2[i]+1;
grid2[k] = i;
/*
* And since we've now visited a new
* domino, add m to the to-do list.
*/
assert(todo < wh);
list[todo++] = m;
}
}
if (j < nd) {
i = k;
#ifdef GENERATION_DIAGNOSTICS
printf("terminating b.f.s. loop, i = %d\n", i);
#endif
break;
}
i = -1; /* just in case the loop terminates */
}
/*
* We expect this b.f.s. to have found us a target
* square.
*/
assert(i >= 0);
/*
* Now we can follow the trail back to our starting
* singleton, re-laying dominoes as we go.
*/
while (1) {
j = grid2[i];
assert(j >= 0 && j < wh);
k = grid[j];
grid[i] = j;
grid[j] = i;
#ifdef GENERATION_DIAGNOSTICS
printf("filling in domino %d/%d (next %d)\n", i, j, k);
#endif
if (j == k)
break; /* we've reached the other singleton */
i = k;
}
#ifdef GENERATION_DIAGNOSTICS
printf("fixup path completed\n");
#endif
}
}
/* vim: set shiftwidth=4 :set textwidth=80: */