Data update

Task/N-queens-problem/C/n-queens-problem-3.c

@@ -1,91 +1,38 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 
-typedef unsigned int uint;
-uint count = 0;
+typedef uint32_t uint;
+uint full, *qs, count = 0, nn;
 
-#define ulen sizeof(uint) * 8
-
-/* could have defined as int solve(...), but void may have less
-   chance to confuse poor optimizer */
-void solve(int n)
+void solve(uint d, uint c, uint l, uint r)
 {
-	int cnt = 0;
-	const uint full = -(int)(1 << (ulen - n));
-	register uint bits, pos, *m, d, e;
-
-	uint b0, b1, l[32], r[32], c[32], mm[33] = {0};
-	n -= 3;
-	/* require second queen to be left of the first queen, so
-	   we ever only test half of the possible solutions. This
-	   is why we can't handle n=1 here */
-	for (b0 = 1U << (ulen - n - 3); b0; b0 <<= 1) {
-		for (b1 = b0 << 2; b1; b1 <<= 1) {
-			d = n;
-			/* c: columns occupied by previous queens.
-			   l: columns attacked by left diagonals
-			   r: by right diagnoals */
-			c[n] = b0 | b1;
-			l[n] = (b0 << 2) | (b1 << 1);
-			r[n] = (b0 >> 2) | (b1 >> 1);
-
-			/* availabe columns on current row. m is stack */
-			bits = *(m = mm + 1) = full & ~(l[n] | r[n] | c[n]);
-
-			while (bits) {
-				/* d: depth, aka row. counting backwards
-				   because !d is often faster than d != n */
-				while (d) {
-					/* pos is right most nonzero bit */
-					pos = -(int)bits & bits;
-
-					/* mark bit used. only put current bits
-					   on stack if not zero, so backtracking
-					   will skip exhausted rows (because reading
-					   stack variable is sloooow compared to
-					   registers) */
-					if ((bits &= ~pos))
-						*m++ = bits | d;
-
-					/* faster than l[d+1] = l[d]... */
-					e = d--;
-					l[d] = (l[e] | pos) << 1;
-					r[d] = (r[e] | pos) >> 1;
-					c[d] =  c[e] | pos;
-
-					bits = full & ~(l[d] | r[d] | c[d]);
-
-					if (!bits) break;
-					if (!d) { cnt++; break; }
-				}
-				/* Bottom of stack m is a zero'd field acting
-				   as sentinel.  When saving to stack, left
-				   27 bits are the available columns, while
-				   right 5 bits is the depth. Hence solution
-				   is limited to size 27 board -- not that it
-				   matters in foreseeable future. */
-				d = (bits = *--m) & 31U;
-				bits &= ~31U;
-			}
-		}
+	uint b, a, *s;
+	if (!d) {
+		count++;
+#if 0
+		printf("\nNo. %d\n===========\n", count);
+		for (a = 0; a < nn; a++, putchar('\n'))
+			for (b = 0; b < nn; b++, putchar(' '))
+				putchar(" -QQ"[((b == qs[a])<<1)|((a + b)&1)]);
+#endif
+		return;
 	}
-	count = cnt * 2;
+
+	a = (c | (l <<= 1) | (r >>= 1)) & full;
+	if (a != full)
+		for (*(s = qs + --d) = 0, b = 1; b <= full; (*s)++, b <<= 1)
+			if (!(b & a)) solve(d, b|c, b|l, b|r);
 }
 
-int main(int c, char **v)
+int main(int n, char **argv)
 {
-	int nn;
-	if (c <= 1 || (nn = atoi(v[1])) <= 0) nn = 8;
+	if (n <= 1 || (nn = atoi(argv[1])) <= 0) nn = 8;
 
-	if (nn > 27) {
-		fprintf(stderr, "Value too large, abort\n");
-		exit(1);
-	}
-
-	/* Can't solve size 1 board; might as well skip 2 and 3 */
-	if (nn < 4) count = nn == 1;
-	else	    solve(nn);
+	qs = calloc(nn, sizeof(int));
+	full = (1U << nn) - 1;
 
+	solve(nn, 0, 0, 0);
 	printf("\nSolutions: %d\n", count);
 	return 0;
 }