880 lines
32 KiB
Java
880 lines
32 KiB
Java
package puzzle;
|
|
|
|
import lombok.Getter;
|
|
import lombok.val;
|
|
import precomp.Neighbors9x8;
|
|
import precomp.Neighbors9x8.nbrs_16;
|
|
import precomp.Neighbors9x8.nbrs_8;
|
|
import precomp.Neighbors9x8.rci;
|
|
import puzzle.Export.Bit;
|
|
import puzzle.Export.Bit1029;
|
|
import puzzle.Export.Gridded;
|
|
import puzzle.Export.Strings;
|
|
import java.io.IOException;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.Locale;
|
|
import java.util.stream.IntStream;
|
|
import static java.nio.charset.StandardCharsets.*;
|
|
|
|
/**
|
|
* SwedishGenerator.java
|
|
*
|
|
* Usage:
|
|
* javac SwedishGenerator.java
|
|
* java SwedishGenerator [--seed N] [--pop N] [--gens N] [--tries N] [--words word-list.txt]
|
|
*/
|
|
@SuppressWarnings("ALL")
|
|
public record SwedishGenerator(Rng rng) {
|
|
|
|
record CandidateInfo(int[] indices, int count) {
|
|
|
|
public CandidateInfo(int n) { this(null, n); }
|
|
}
|
|
|
|
//@formatter:off
|
|
@FunctionalInterface interface SlotVisitor { void visit(int key, long packedPos, int len); }
|
|
//@formatter:on
|
|
static final long GT_1_OFFSET_53_BIT = 0x3E00000000000000L;
|
|
static final long X = 0L;
|
|
static final int LOG_EVERY_MS = 200;
|
|
static final int BAR_LEN = 22;
|
|
static final int C = Config.PUZZLE_COLS;
|
|
static final double CROSS_R = (C - 1) / 2.0;
|
|
static final int R = Config.PUZZLE_ROWS;
|
|
static final double CROSS_C = (R - 1) / 2.0;
|
|
static final int SIZE = C * R;// ~18
|
|
static final int SIZE_MIN_1 = SIZE - 1;// ~18
|
|
static final double SIZED = (double) SIZE;// ~18
|
|
static final int TARGET_CLUES = SIZE >> 2;
|
|
static final int MAX_WORD_LENGTH = C <= R ? C : R;
|
|
static final int MAX_WORD_LENGTH7 = MAX_WORD_LENGTH * 7;
|
|
static final int MAX_WORD_LENGTH_PLUS_ONE = MAX_WORD_LENGTH + 1;
|
|
static final int MIN_LEN = Config.MIN_LEN;
|
|
static final int MIN_LEN7 = Config.MIN_LEN * 7;
|
|
static final int CLUE_SIZE = Config.CLUE_SIZE;
|
|
static final int SIMPLICITY_DEFAULT_SCORE = 2;
|
|
static final int MAX_TRIES_PER_SLOT = Config.MAX_TRIES_PER_SLOT;
|
|
static final char C_DASH = '\0';
|
|
static final byte _1 = 49, _9 = 57, A = 65, Z = 90, DASH = (byte) C_DASH;
|
|
static final ThreadLocal<Context> CTX = ThreadLocal.withInitial(Context::new);
|
|
static boolean isLetter(byte b) { return (b & 64) != 0; }
|
|
static int clamp(int x, int a, int b) { return Math.max(a, Math.min(b, x)); }
|
|
record Pick(Slot slot, CandidateInfo info, boolean done) { }
|
|
|
|
// Directions for '1'..'6'
|
|
static final nbrs_16[] OFFSETS = Neighbors9x8.OFFSETS;
|
|
static final nbrs_16[] OFFSETS_FOUR = Neighbors9x8.OFFSETS_FOUR;
|
|
static final nbrs_8[] nbrs8 = Neighbors9x8.nbrs8;
|
|
static final nbrs_8[] nbrs4 = Neighbors9x8.nbrs4;
|
|
static final rci[] IT = Neighbors9x8.IT;
|
|
static final long[] INBR8_PACKEDT = Neighbors9x8.NBR8_PACKED;
|
|
static final int[][] MUTATE_RI = new int[SIZE][625];
|
|
|
|
static {
|
|
for (int i = 0; i < SIZE; i++) {
|
|
int k = 0;
|
|
for (int dr1 = -2; dr1 <= 2; dr1++)
|
|
for (int dr2 = -2; dr2 <= 2; dr2++)
|
|
for (int dc1 = -2; dc1 <= 2; dc1++)
|
|
for (int dc2 = -2; dc2 <= 2; dc2++)
|
|
MUTATE_RI[i][k++] = Grid.offset(clamp(Grid.r(i) + dr1 + dr2, 0, R - 1),
|
|
clamp(Grid.c(i) + dc1 + dc2, 0, C - 1));
|
|
}
|
|
}
|
|
/*static {
|
|
Rng trng = new Rng(1);
|
|
for (int i = 0; i < SIZE; i++) {
|
|
int[] neighborhood = new int[625];
|
|
int k = 0;
|
|
for (int dr1 = -2; dr1 <= 2; dr1++)
|
|
for (int dr2 = -2; dr2 <= 2; dr2++)
|
|
for (int dc1 = -2; dc1 <= 2; dc1++)
|
|
for (int dc2 = -2; dc2 <= 2; dc2++)
|
|
neighborhood[k++] = Grid.offset(clamp(Grid.r(i) + dr1 + dr2, 0, R - 1),
|
|
clamp(Grid.c(i) + dc1 + dc2, 0, C - 1));
|
|
for (k = 0; k < 625; k++) {
|
|
long packed = 0;
|
|
for (int s = 0; s < 4; s++) {
|
|
int ri = neighborhood[trng.randint(0, 624)];
|
|
int d = trng.randint(1, 4);
|
|
packed |= ((long) ri | ((long) d << 8)) << (s << 4);
|
|
}
|
|
MUTATE_RI[i][k] = packed;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
static final Pick PICK_DONE = new Pick(null, null, true);
|
|
static final Pick PICK_NOT_DONE = new Pick(null, null, false);
|
|
|
|
public static final class FillStats {
|
|
|
|
public long nodes;
|
|
public long backtracks;
|
|
public double seconds;
|
|
public int lastMRV;
|
|
public double simplicity;
|
|
}
|
|
|
|
public static record FillResult(boolean ok,
|
|
Gridded grid,
|
|
HashMap<Integer, Lemma> clueMap,
|
|
FillStats stats) {
|
|
|
|
public FillResult {
|
|
if (ok) {
|
|
clueMap.forEach((k, v) -> stats.simplicity += v.simpel);
|
|
stats.simplicity = clueMap.isEmpty() ? 0 : stats.simplicity / clueMap.size();
|
|
}
|
|
}
|
|
}
|
|
|
|
static record Context(int[] covH,
|
|
int[] covV,
|
|
int[] cellCount,
|
|
int[] stack,
|
|
Bit seen,
|
|
byte[] pattern,
|
|
IntList[] intListBuffer,
|
|
int[] undo,
|
|
int[] inter1,
|
|
int[] inter2) {
|
|
|
|
public Context() {
|
|
this(new int[SIZE], new int[SIZE], new int[SIZE], new int[SIZE], new Bit(), new byte[MAX_WORD_LENGTH], new IntList[MAX_WORD_LENGTH],
|
|
new int[2048], new int[160000], new int[160000]);
|
|
}
|
|
void setPatter(byte[] chars) { System.arraycopy(chars, 0, this.pattern, 0, chars.length); }
|
|
}
|
|
|
|
static final class Rng {
|
|
|
|
@Getter private int x;
|
|
Rng(int seed) {
|
|
var s = seed;
|
|
if (s == 0) s = 1;
|
|
this.x = s;
|
|
}
|
|
int nextU32() {
|
|
var y = x;
|
|
y ^= (y << 13);
|
|
y ^= (y >>> 17);
|
|
y ^= (y << 5);
|
|
x = y;
|
|
return y;
|
|
}
|
|
byte randbyte(int min, int max) {
|
|
var u = (nextU32() & 0xFFFFFFFFL);
|
|
var range = (long) max - (long) min + 1L;
|
|
return (byte) (min + (u % range));
|
|
}
|
|
int randint2bit() { return nextU32() & 3; }
|
|
int randint(int min, int max) {
|
|
var u = (nextU32() & 0xFFFFFFFFL);
|
|
var range = (long) max - (long) min + 1L;
|
|
return (int) (min + (u % range));
|
|
}
|
|
double nextFloat() { return (nextU32() & 0xFFFFFFFFL) / 4294967295.0; }
|
|
}
|
|
|
|
static class Grid {
|
|
|
|
final byte[] g;
|
|
long lo, hi;
|
|
|
|
public Grid(byte[] g) { this(g, 0, 0); }
|
|
public Grid(byte[] g, long lo, long hi) {
|
|
this.g = g;
|
|
this.lo = lo;
|
|
this.hi = hi;
|
|
}
|
|
static Grid createEmpty() { return new Grid(new byte[SIZE], X, X); }
|
|
int digitAt(int index) { return g[index] - 48; }
|
|
public static int r(int offset) { return offset & 7; }
|
|
public static int c(int offset) { return offset >>> 3; }
|
|
static int offset(int r, int c) { return r | (c << 3); }
|
|
Grid deepCopyGrid() { return new Grid(g.clone(), lo, hi); }
|
|
public byte byteAt(int pos) { return g[pos]; }
|
|
void setByteAt(int idx, byte ch) { g[idx] = ch; }
|
|
void setClue(int idx, byte ch) {
|
|
g[idx] = ch;
|
|
if (idx < 64) lo |= (1L << idx);
|
|
else hi |= (1L << (idx & 63));
|
|
}
|
|
void clear(int idx) { g[idx] = DASH; }
|
|
void clearClue(int idx) {
|
|
g[idx] = DASH;
|
|
if (idx < 64) lo &= ~(1L << idx);
|
|
else hi &= ~(1L << (idx & 63));
|
|
}
|
|
static boolean isDigit(byte b) { return (b & B48) == B48; }
|
|
boolean isDigitAt(int index) { return isDigit(g[index]); }
|
|
boolean isClue(long index) {
|
|
if (index < 64) return ((lo >> index) & 1L) != X;
|
|
return ((hi >> (index & 63)) & 1L) != X;
|
|
}
|
|
boolean isClue(int index) {
|
|
if (index < 64) return ((lo >> index) & 1L) != 0;
|
|
return ((hi >> (index & 63)) & 1L) != 0;
|
|
}
|
|
boolean notClue(long index) {
|
|
if (index < 64) return ((lo >> index) & 1L) == X;
|
|
return ((hi >> (index & 63)) & 1L) == X;
|
|
}
|
|
boolean notClue(int index) {
|
|
if (index < 64) return ((lo >> index) & 1L) == X;
|
|
return ((hi >> (index & 63)) & 1L) == X;
|
|
}
|
|
boolean clueless(int idx) {
|
|
if (idx < 64) {
|
|
val test = (1L << idx);
|
|
if ((test & lo) == X) return false;
|
|
g[idx] = DASH;
|
|
|
|
lo &= ~test;
|
|
} else {
|
|
val test = (1L << (idx & 63));
|
|
if ((test & hi) == X) return false;
|
|
g[idx] = DASH;
|
|
|
|
hi &= ~test;
|
|
}
|
|
return true;
|
|
}
|
|
static final byte B0 = (byte) 0;
|
|
static final byte B64 = (byte) 64;
|
|
static final byte B48 = (byte) 48;
|
|
static boolean isLetter(byte b) { return (b & B64) != B0; }
|
|
public boolean isLetterSet(int idx) { return isLetter(g[idx]); }
|
|
static boolean notDigit(byte b) { return (b & B48) != B48; }
|
|
public boolean isLetterAt(int index) { return notDigit(g[index]); }
|
|
|
|
public double similarity(Grid b) {
|
|
var same = 0;
|
|
for (int i = 0; i < SIZE; i++) if (g[i] == b.g[i]) same++;
|
|
return same / SIZED;
|
|
}
|
|
int clueCount() { return Long.bitCount(lo) + Long.bitCount(hi); }
|
|
boolean hasRoomForClue(long packed) { return (packed & GT_1_OFFSET_53_BIT) != X && notClue(packed & 0x7FL) && notClue((packed >>> 7) & 0x7FL); }
|
|
void forEachSlot(SlotVisitor visitor) {
|
|
for (var l = lo; l != X; l &= l - 1) processSlot(this, visitor, Long.numberOfTrailingZeros(l));
|
|
for (var h = hi; h != X; h &= h - 1) processSlot(this, visitor, 64 | Long.numberOfTrailingZeros(h));
|
|
}
|
|
}
|
|
|
|
static final class IntList {
|
|
|
|
int[] a = new int[8];
|
|
int n = 0;
|
|
void add(int v) {
|
|
if (n >= a.length) a = Arrays.copyOf(a, a.length * 2);
|
|
a[n++] = v;
|
|
}
|
|
int size() { return n; }
|
|
int[] data() { return a; }
|
|
}
|
|
|
|
static record DictEntry(ArrayList<Lemma> words, IntList[][] pos) {
|
|
|
|
public DictEntry(int L) {
|
|
this(new ArrayList<>(), new IntList[L][26]);
|
|
for (var i = 0; i < L; i++) for (var j = 0; j < 26; j++) pos[i][j] = new IntList();
|
|
}
|
|
}
|
|
|
|
public static record Lemma(int index, long word, byte len, short simpel) {
|
|
|
|
static int LEMMA_COUNTER = 0;
|
|
static long pack(byte[] b) {
|
|
long w = 0;
|
|
for (var i = 0; i < b.length; i++) w |= ((long) b[i] & ~64) << (i * 5);
|
|
return w;
|
|
}
|
|
public Lemma(int index, String word, int simpel) { this(index, pack(word.getBytes(US_ASCII)), (byte) word.length(), (short) simpel); }
|
|
public Lemma(String word, int simpel) { this(LEMMA_COUNTER++, word, simpel); }
|
|
byte byteAt(int idx) { return (byte) ((word >>> (idx * 5)) & 0b11111 | Grid.B64); }// word[]; }
|
|
@Override public int hashCode() { return index; }
|
|
@Override public boolean equals(Object o) { return (o == this) || (o instanceof Lemma l && l.index == index); }
|
|
String[] clue() { return CsvIndexService.clues(index); }
|
|
public String asWord() {
|
|
var b = new byte[len];
|
|
for (var i = 0; i < len; i++) b[i] = (byte) ((word >>> (i * 5)) & 0b11111 | Grid.B64);
|
|
return new String(b, US_ASCII);
|
|
}
|
|
}
|
|
|
|
public static record Dict(
|
|
DictEntry[] index,
|
|
int length) {
|
|
|
|
public Dict(Lemma[] wordz) {
|
|
var index = new DictEntry[MAX_WORD_LENGTH_PLUS_ONE];
|
|
Arrays.setAll(index, i -> new DictEntry(i));
|
|
for (var lemma : wordz) {
|
|
var L = lemma.len;
|
|
|
|
var entry = index[L];
|
|
var idx = entry.words.size();
|
|
entry.words.add(lemma);
|
|
|
|
for (var i = 0; i < L; i++) {
|
|
var letter = lemma.byteAt(i) - 'A';
|
|
if (letter < 0 || letter >= 26) throw new RuntimeException("Illegal letter: " + letter + " in word " + lemma);
|
|
entry.pos[i][letter].add(idx);
|
|
}
|
|
}
|
|
for (int i = MIN_LEN; i < index.length; i++) if (index[i].words.size() <= 0) throw new RuntimeException("No words for length " + i);
|
|
this(index, Arrays.stream(index).mapToInt(i -> i.words.size()).sum());
|
|
}
|
|
static Dict loadDict(String wordsPath) {
|
|
try {
|
|
var map = new ArrayList<Lemma>();
|
|
Files.lines(Path.of(wordsPath), UTF_8).forEach(line -> CsvIndexService.lineToLemma(line, map::add));
|
|
return new Dict(map.toArray(Lemma[]::new));
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
throw new RuntimeException("Failed to load dictionary from " + wordsPath, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int intersectSorted(int[] a, int aLen, int[] b, int bLen, int[] out) {
|
|
if (aLen == 0 || bLen == 0) return 0;
|
|
if (aLen < bLen >>> 4) {
|
|
int k = 0;
|
|
for (int i = 0; i < aLen; i++) {
|
|
int x = a[i];
|
|
if (Arrays.binarySearch(b, 0, bLen, x) >= 0) out[k++] = x;
|
|
}
|
|
return k;
|
|
}
|
|
if (bLen < aLen >>> 4) {
|
|
int k = 0;
|
|
for (int i = 0; i < bLen; i++) {
|
|
int y = b[i];
|
|
if (Arrays.binarySearch(a, 0, aLen, y) >= 0) out[k++] = y;
|
|
}
|
|
return k;
|
|
}
|
|
int i = 0, j = 0, k = 0, x, y;
|
|
while (i < aLen && j < bLen) {
|
|
x = a[i];
|
|
y = b[j];
|
|
if (x == y) {
|
|
out[k++] = x;
|
|
i++;
|
|
j++;
|
|
} else if (x < y) i++;
|
|
else j++;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
static record Slot(int key, long packedPos) {
|
|
|
|
static Slot from(int key, long packedPos, int len) { return new Slot(key, packedPos | ((long) len << 56)); }
|
|
void undoPlace(Grid grid, int mask) { for (int i = 0, len = len(); i < len; i++) if ((mask & (1L << i)) != 0) grid.clear(pos(i)); }
|
|
public int len() { return (int) (packedPos >>> 56); }
|
|
public int clueR() { return Grid.r((key >>> 4)); }
|
|
public int clueIndex() { return key >>> 4; }
|
|
public int clueC() { return Grid.c((key >>> 4)); }
|
|
public int dir() { return key & 15; }
|
|
public boolean horiz() { return horiz(key); }
|
|
public int pos(int i) { return offset(packedPos, i); }
|
|
public static boolean horiz(int key) { return (key & 1) == 0/*((key & 15) & 1) == 0*/; }
|
|
public static int offset(long packedPos, int i) { return (int) ((packedPos >> (i * 7)) & 127); }
|
|
}
|
|
|
|
private static void processSlot(Grid grid, SlotVisitor visitor, int idx) {
|
|
var d = grid.digitAt(idx);
|
|
var packed = OFFSETS[d].path()[idx];
|
|
long packedPos = 0;
|
|
int k = 0;
|
|
for (int n = (int) (packed >>> 56), iidx; k < n && k < MAX_WORD_LENGTH; k++) {
|
|
iidx = (int) ((packed >>> (k * 7)) & 0x7F);
|
|
if (grid.isClue(iidx)) break;
|
|
packedPos |= (long) iidx << (k * 7);
|
|
}
|
|
if (k > 0) {
|
|
visitor.visit((idx << 4) | d, packedPos, k);
|
|
}
|
|
}
|
|
|
|
static ArrayList<Slot> extractSlots(Grid grid) {
|
|
var slots = new ArrayList<Slot>(32);
|
|
grid.forEachSlot((key, packedPos, len) -> slots.add(Slot.from(key, packedPos, len)));
|
|
return slots;
|
|
}
|
|
|
|
long maskFitness(Grid grid) {
|
|
var ctx = CTX.get();
|
|
var covH = ctx.covH;
|
|
var covV = ctx.covV;
|
|
Arrays.fill(covH, 0, SIZE, 0);
|
|
Arrays.fill(covV, 0, SIZE, 0);
|
|
|
|
long lo_cl = grid.lo, hi_cl = grid.hi;
|
|
long penalty = (((long) Math.abs(grid.clueCount() - TARGET_CLUES)) << 3);
|
|
boolean hasSlots = false;
|
|
|
|
for (int i = 0; i < 65; i += 64) {
|
|
for (long bits = (i == 0 ? lo_cl : hi_cl); bits != X; bits &= bits - 1) {
|
|
int clueIdx = i + Long.numberOfTrailingZeros(bits);
|
|
var d = grid.digitAt(clueIdx);
|
|
var nbrs16 = OFFSETS[d];
|
|
long packed = nbrs16.path()[clueIdx];
|
|
int n = (int) (packed >>> 56) * 7, k, idx;
|
|
var horiz = Slot.horiz(d) ? covH : covV;
|
|
for (k = 0; k < n && k < MAX_WORD_LENGTH7; k += 7) {
|
|
idx = (int) ((packed >>> (k)) & 0x7F);
|
|
if (grid.isClue(idx)) break;
|
|
horiz[idx] += 1;
|
|
}
|
|
if (k > 0) {
|
|
hasSlots = true;
|
|
if (k < MIN_LEN7) penalty += 8000;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!hasSlots) return 1_000_000_000L;
|
|
|
|
var seen = ctx.seen;
|
|
var stack = ctx.stack;
|
|
seen.clear();
|
|
|
|
for (int i = 0; i < 65; i += 64) {
|
|
for (long bits = (i == 0 ? lo_cl : hi_cl); bits != X; bits &= bits - 1) {
|
|
int clueIdx = i + Long.numberOfTrailingZeros(bits);
|
|
if (seen.get(clueIdx)) continue;
|
|
int size = 0;
|
|
stack[0] = clueIdx;
|
|
seen.set(clueIdx);
|
|
for (int sp = 1; sp > 0; size++) {
|
|
long packed = Neighbors9x8.NBR8_PACKED[stack[--sp]];
|
|
for (int k = 0, n = (int) (packed >>> 56) * 7; k < n; k += 7) {
|
|
int nidx = (int) ((packed >>> k) & 0x7F);
|
|
if (seen.get(nidx) || grid.notClue(nidx)) continue;
|
|
seen.set(nidx);
|
|
stack[sp++] = nidx;
|
|
}
|
|
}
|
|
if (size >= 2) penalty += ((size - 1L) * 120L);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 65; i += 64) {
|
|
long bits = (i == 0 ? ~lo_cl : (~hi_cl & 0xFFL));
|
|
for (; bits != X; bits &= bits - 1) {
|
|
int idx = i + Long.numberOfTrailingZeros(bits);
|
|
var rci = IT[idx];
|
|
if ((4 - rci.nbrCount()) + Long.bitCount(rci.n1() & lo_cl) + Long.bitCount(rci.n2() & hi_cl) >= 3) penalty += 400;
|
|
var h = covH[idx];
|
|
var v = covV[idx];
|
|
if (h == 0 && v == 0) penalty += 1500;
|
|
else if (h > 0 && v > 0) { /* ok */ } else if (h + v == 1) penalty += 200;
|
|
else penalty += 600;
|
|
}
|
|
}
|
|
|
|
return penalty;
|
|
}
|
|
|
|
Grid randomMask() {
|
|
var g = Grid.createEmpty();
|
|
for (int placed = 0, guard = 0, idx; placed < TARGET_CLUES && guard < 4000; guard++) {
|
|
idx = rng.randint(0, SIZE_MIN_1);
|
|
if (g.isClue(idx)) continue;
|
|
var d = OFFSETS_FOUR[rng.randint2bit()];
|
|
|
|
if (g.hasRoomForClue(d.path()[idx])) {
|
|
g.setClue(idx, d.dbyte());
|
|
placed++;
|
|
}
|
|
}
|
|
return g;
|
|
}
|
|
Grid mutate(Grid grid) {
|
|
var g = grid.deepCopyGrid();
|
|
int ri;
|
|
var bytes = MUTATE_RI[rng.randint(0, SIZE_MIN_1)];
|
|
nbrs_16 d;
|
|
for (var k = 0; k < 4; k++) {
|
|
ri = bytes[rng.randint(0, 624)];
|
|
if (!g.clueless(ri)) {
|
|
d = OFFSETS_FOUR[rng.randint2bit()];
|
|
if (g.hasRoomForClue(d.path()[ri])) g.setClue(ri, d.dbyte());
|
|
}
|
|
}
|
|
return g;
|
|
}
|
|
Grid crossover(Grid a, Grid b) {
|
|
var out = a.deepCopyGrid();
|
|
var theta = rng.nextFloat() * Math.PI;
|
|
var nc = Math.cos(theta);
|
|
var nr = Math.sin(theta);
|
|
|
|
long bo0 = out.lo, bo1 = out.hi;
|
|
for (var rci : IT) {
|
|
int i = rci.i();
|
|
if ((rci.cross_r()) * nc + (rci.cross_c()) * nr < 0) {
|
|
byte ch = b.g[i];
|
|
if (out.g[i] != ch) {
|
|
out.g[i] = ch;
|
|
if (Grid.isDigit(ch)) {
|
|
if (i < 64) bo0 |= (1L << i);
|
|
else bo1 |= (1L << (i & 63));
|
|
} else {
|
|
if (i < 64) bo0 &= ~(1L << i);
|
|
else bo1 &= ~(1L << (i & 63));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
out.lo = bo0;
|
|
out.hi = bo1;
|
|
for (var lo = out.lo; lo != X; lo &= lo - 1L) clearClues(out, Long.numberOfTrailingZeros(lo));
|
|
for (var hi = out.hi; hi != X; hi &= hi - 1L) clearClues(out, 64 + Long.numberOfTrailingZeros(hi));
|
|
return out;
|
|
}
|
|
public static void clearClues(Grid out, int idx) { if (!out.hasRoomForClue(OFFSETS[out.digitAt(idx)].path()[idx])) out.clearClue(idx); }
|
|
|
|
Grid hillclimb(Grid start, int limit) {
|
|
var best = start;
|
|
var bestF = maskFitness(best);
|
|
var fails = 0;
|
|
|
|
while (fails < limit) {
|
|
var cand = mutate(best);
|
|
var f = maskFitness(cand);
|
|
if (f < bestF) {
|
|
best = cand;
|
|
bestF = f;
|
|
fails = 0;
|
|
} else {
|
|
fails++;
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
public Grid generateMask(int popSize, int gens, int pairs) {
|
|
class GridAndFit {
|
|
|
|
Grid grid;
|
|
long fite = -1;
|
|
GridAndFit(Grid grid) { this.grid = grid; }
|
|
long fit() {
|
|
if (fite == -1) this.fite = maskFitness(grid);
|
|
return this.fite;
|
|
}
|
|
}
|
|
if (Main.VERBOSE) System.out.println("generateMask init pop: " + popSize);
|
|
var pop = new ArrayList<GridAndFit>();
|
|
for (var i = 0; i < popSize; i++) {
|
|
pop.add(new GridAndFit(hillclimb(randomMask(), 180)));
|
|
}
|
|
|
|
for (var gen = 0; gen < gens; gen++) {
|
|
if (Thread.currentThread().isInterrupted()) break;
|
|
var children = new ArrayList<GridAndFit>();
|
|
|
|
for (var k = 0; k < pairs; k++) {
|
|
var p1 = pop.get(rng.randint(0, pop.size() - 1));
|
|
var p2 = pop.get(rng.randint(0, pop.size() - 1));
|
|
var child = crossover(p1.grid, p2.grid);
|
|
children.add(new GridAndFit(hillclimb(child, 70)));
|
|
}
|
|
|
|
pop.addAll(children);
|
|
pop.sort(Comparator.comparingLong(GridAndFit::fit));
|
|
|
|
var next = new ArrayList<GridAndFit>();
|
|
for (var cand : pop) {
|
|
if (next.size() >= popSize) break;
|
|
var ok = true;
|
|
for (var kept : next) {
|
|
if (cand.grid.similarity(kept.grid) > 0.92) {
|
|
ok = false;
|
|
break;
|
|
}
|
|
}
|
|
if (ok) next.add(cand);
|
|
}
|
|
pop = next;
|
|
|
|
if (Main.VERBOSE && (gen & 15) == 15) System.out.println(" gen " + gen + "/" + gens + " bestFitness=" + pop.get(0).fit());
|
|
}
|
|
|
|
pop.sort(Comparator.comparingLong(GridAndFit::fit));
|
|
return pop.get(0).grid;
|
|
}
|
|
static void patternForSlot(Grid grid, Slot s, byte[] pat) {
|
|
byte ch;
|
|
for (int i = 0, len = s.len(); i < len; i++) {
|
|
ch = grid.byteAt(s.pos(i));
|
|
pat[i] = isLetter(ch) ? ch : DASH;
|
|
}
|
|
}
|
|
|
|
static int slotScore(int[] count, Slot s) {
|
|
int cross = 0, len = s.len();
|
|
for (int i = 0; i < len; i++) cross += (count[s.pos(i)] - 1);
|
|
return cross * 10 + len;
|
|
}
|
|
static boolean placeWord(Grid grid, Slot s, Lemma w, int[] undoBuffer, int offset) {
|
|
int mask = 0;
|
|
byte cur, ch;
|
|
for (int i = 0, leng = s.len(), idx; i < leng; i++) {
|
|
idx = s.pos(i);
|
|
cur = grid.byteAt(idx);
|
|
ch = w.byteAt(i);
|
|
if (cur == DASH) {
|
|
mask |= (1 << i);
|
|
grid.setByteAt(idx, ch);
|
|
} else if (cur != ch) {
|
|
for (var j = 0; j < i; j++) {
|
|
if ((mask & (1 << j)) != 0) {
|
|
grid.clear(s.pos(j));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
undoBuffer[offset] = mask;
|
|
return true;
|
|
}
|
|
static final CandidateInfo[] CANDIDATES = IntStream.range(0, 10192 << 2).mapToObj(CandidateInfo::new).toArray(CandidateInfo[]::new);
|
|
static CandidateInfo candidateInfoForPattern(Context ctx, DictEntry entry, int len) {
|
|
var pattern = ctx.pattern;
|
|
var listBuffer = ctx.intListBuffer;
|
|
var listCount = 0;
|
|
IntList tmp;
|
|
byte ch;
|
|
for (var i = 0; i < len; i++) {
|
|
ch = pattern[i];
|
|
if (isLetter(ch)) {
|
|
listBuffer[listCount++] = entry.pos[i][ch - 'A'];
|
|
}
|
|
}
|
|
|
|
if (listCount == 0) {
|
|
return CANDIDATES[entry.words.size()];
|
|
}
|
|
|
|
// Sort constraints by size to optimize intersection
|
|
for (var i = 0; i < listCount - 1; i++) {
|
|
for (var j = i + 1; j < listCount; j++) {
|
|
if (listBuffer[j].size() < listBuffer[i].size()) {
|
|
tmp = listBuffer[i];
|
|
listBuffer[i] = listBuffer[j];
|
|
listBuffer[j] = tmp;
|
|
}
|
|
}
|
|
}
|
|
|
|
var cur = listBuffer[0].data();
|
|
var curLen = listBuffer[0].size();
|
|
if (listCount == 1) return new CandidateInfo(cur, curLen);
|
|
|
|
val b1 = ctx.inter1;
|
|
val b2 = ctx.inter2;
|
|
var in = cur;
|
|
var out = b1;
|
|
|
|
for (var k = 1; k < listCount; k++) {
|
|
tmp = listBuffer[k];
|
|
curLen = intersectSorted(in, curLen, tmp.data(), tmp.size(), out);
|
|
in = out;
|
|
out = (out == b1) ? b2 : b1;
|
|
if (curLen == 0) break;
|
|
}
|
|
|
|
return new CandidateInfo(in, curLen);
|
|
}
|
|
public FillResult fillMask(Grid mask, DictEntry[] dictIndex,
|
|
int timeLimitMs) {
|
|
val multiThreaded = Thread.currentThread().getName().contains("pool");
|
|
val grid = mask.deepCopyGrid();
|
|
val used = new Bit1029();
|
|
val assigned = new HashMap<Integer, Lemma>();
|
|
val ctx = CTX.get();
|
|
val count = ctx.cellCount;
|
|
Arrays.fill(count, 0, SIZE, 0);
|
|
|
|
val slots = extractSlots(grid);
|
|
for (var s : slots) for (int i = 0, len = s.len(); i < len; i++) count[s.pos(i)]++;
|
|
|
|
val slotScores = new int[slots.size()];
|
|
for (int i = 0; i < slots.size(); i++) slotScores[i] = slotScore(count, slots.get(i));
|
|
|
|
val t0 = System.currentTimeMillis();
|
|
val stats = new FillStats();
|
|
val TOTAL = slots.size();
|
|
|
|
class Solver {
|
|
|
|
long lastLog = t0;
|
|
void renderProgress() {
|
|
if (!Main.VERBOSE || multiThreaded) return;
|
|
var now = System.currentTimeMillis();
|
|
if ((now - lastLog) < LOG_EVERY_MS) return;
|
|
lastLog = (now);
|
|
|
|
var done = assigned.size();
|
|
var pct = (TOTAL == 0) ? 100 : (int) Math.floor((done / (double) TOTAL) * 100);
|
|
var filled = Math.min(BAR_LEN, (int) Math.floor((pct / 100.0) * BAR_LEN));
|
|
var bar = "[" + "#".repeat(filled) + "-".repeat(BAR_LEN - filled) + "]";
|
|
var elapsed = String.format(Locale.ROOT, "%.1fs", (now - t0) / 1000.0);
|
|
|
|
var msg = String.format(
|
|
Locale.ROOT,
|
|
"%s %d/%d slots | nodes=%d | backtracks=%d | mrv=%d | %s",
|
|
bar, done, TOTAL, stats.nodes, stats.backtracks, stats.lastMRV, elapsed
|
|
);
|
|
System.out.print("\r" + Strings.padRight(msg, 120));
|
|
System.out.flush();
|
|
}
|
|
Pick chooseMRV() {
|
|
Slot best = null;
|
|
CandidateInfo bestInfo = null;
|
|
int bestScore = -1;
|
|
for (int i = 0, n = slots.size(); i < n; i++) {
|
|
var s = slots.get(i);
|
|
if (assigned.containsKey(s.key())) continue;
|
|
var entry = dictIndex[s.len()];
|
|
if (entry == null) return PICK_NOT_DONE;
|
|
patternForSlot(grid, s, ctx.pattern);
|
|
var info = candidateInfoForPattern(ctx, entry, s.len());
|
|
|
|
if (info.count == 0) return PICK_NOT_DONE;
|
|
if (best == null
|
|
|| info.count < bestInfo.count
|
|
|| (info.count == bestInfo.count && slotScores[i] > bestScore)) {
|
|
best = s;
|
|
bestScore = slotScores[i];
|
|
if (info.indices != null && (info.indices == ctx.inter1 || info.indices == ctx.inter2)) {
|
|
bestInfo = new CandidateInfo(Arrays.copyOf(info.indices, info.count), info.count);
|
|
} else {
|
|
bestInfo = info;
|
|
}
|
|
if (info.count <= 1) break;
|
|
}
|
|
}
|
|
|
|
if (best == null) return PICK_DONE;
|
|
return new Pick(best, bestInfo, false);
|
|
}
|
|
boolean backtrack(int depth) {
|
|
if (Thread.currentThread().isInterrupted()) return false;
|
|
stats.nodes++;
|
|
|
|
if (timeLimitMs > 0 && (System.currentTimeMillis() - t0) > timeLimitMs) return false;
|
|
|
|
var pick = chooseMRV();
|
|
if (pick.done) return true;
|
|
if (pick.slot == null) {
|
|
stats.backtracks++;
|
|
return false;
|
|
}
|
|
val info = pick.info;
|
|
stats.lastMRV = info.count;
|
|
renderProgress();
|
|
|
|
var s = pick.slot;
|
|
var k = s.key();
|
|
int patLen = s.len();
|
|
var entry = dictIndex[patLen];
|
|
|
|
if (info.indices != null && info.indices.length > 0) {
|
|
var idxs = info.indices;
|
|
var L = idxs.length;
|
|
var tries = Math.min(MAX_TRIES_PER_SLOT, L);
|
|
|
|
for (var t = 0; t < tries; t++) {
|
|
double r = rng.nextFloat();
|
|
int idxInArray = (int) (r * r * r * L);
|
|
var idx = idxs[idxInArray];
|
|
var w = entry.words.get(idx);
|
|
|
|
if (used.get(w.index())) continue;
|
|
|
|
if (!placeWord(grid, s, w, ctx.undo, depth)) continue;
|
|
|
|
used.set(w.index());
|
|
assigned.put(k, w);
|
|
|
|
if (backtrack(depth + 1)) return true;
|
|
|
|
assigned.remove(k);
|
|
used.clear(w.index());
|
|
s.undoPlace(grid, ctx.undo[depth]);
|
|
}
|
|
stats.backtracks++;
|
|
return false;
|
|
}
|
|
|
|
var N = entry.words.size();
|
|
if (N == 0) {
|
|
stats.backtracks++;
|
|
return false;
|
|
}
|
|
|
|
var tries = Math.min(MAX_TRIES_PER_SLOT, N);
|
|
for (var t = 0; t < tries; t++) {
|
|
double r = rng.nextFloat();
|
|
int idxInArray = (int) (r * r * r * N);
|
|
var w = entry.words.get(idxInArray);
|
|
|
|
if (used.get(w.index())) continue;
|
|
|
|
if (!placeWord(grid, s, w, ctx.undo, depth)) continue;
|
|
|
|
used.set(w.index());
|
|
assigned.put(k, w);
|
|
|
|
if (backtrack(depth + 1)) return true;
|
|
|
|
assigned.remove(k);
|
|
used.clear(w.index);
|
|
s.undoPlace(grid, ctx.undo[depth]);
|
|
}
|
|
|
|
stats.backtracks++;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// initial render (same feel)
|
|
var solver = new Solver();
|
|
solver.renderProgress();
|
|
var ok = solver.backtrack(0);
|
|
// final progress line
|
|
if (!multiThreaded) {
|
|
System.out.print("\r" + Strings.padRight("", 120) + "\r");
|
|
System.out.flush();
|
|
}
|
|
|
|
stats.seconds = (System.currentTimeMillis() - t0) / 1000.0;
|
|
var res = new FillResult(ok, new Gridded(grid), assigned, stats);
|
|
|
|
// print a final progress line
|
|
if (Main.VERBOSE && !multiThreaded) {
|
|
System.out.println(
|
|
String.format(Locale.ROOT,
|
|
"[######################] %d/%d slots | nodes=%d | backtracks=%d | mrv=%d | %.1fs",
|
|
assigned.size(), TOTAL, stats.nodes, stats.backtracks, stats.lastMRV, stats.seconds
|
|
)
|
|
);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
}
|