From 4092dadfc6b02b8b6acfa30cacfcd18f7d62aad2 Mon Sep 17 00:00:00 2001
From: Wenyuan Huang <157926136+whuang369@users.noreply.github.com>
Date: Sun, 4 Oct 2026 16:48:09 -0500
Subject: [PATCH] Fix #182: count problem 145 loop solutions with an exact plug
 DP

The checker counted loop solutions with a plain backtracking search over
the 312 grid edges (static edge order, local propagation only) and
stopped early only after finding six solutions. Its cost grows
exponentially with how weakly the clues constrain the board, and weak
clues (many 1s and 2s) are exactly what the task rewards. On such boards
it neither found six solutions nor exhausted the space within the
judge's 10 s checker limit, so the checker was killed and the case
scored 0.

Replace the search with a plug (profile) DP over the 13 x 13 grid
points. The profile holds the vertical edges crossing the sweep line as
a bracket sequence of path ends, one top-edge bit per column for clue
cells whose bottom edge is still open, and a flag for "loop already
closed". It counts edge sets forming exactly one non-empty loop that
satisfies every clue, saturating at six, so the count is exact and does
not depend on how weakly the board is constrained. States live in a
small open-addressing map that packs the count into each entry.

Input validation, the scoring formula and the verdict message are
unchanged. The checker no longer prints solution grids to stderr; the
judge reads only the Ratio: line.

Verified: no mismatches against brute force on small grids (2.29M
instances, every 3x3 clue grid included), against the old checker on 367
boards it finishes, or against an independent SAT counter on 2,434
comparisons covering every bucket from 0 to six or more. The hardest
board found (all 2s with one 3) takes about 1.2 s and 70 MB.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 algorithmic/problems/145/checker.cpp | 603 +++++++--------------------
 1 file changed, 156 insertions(+), 447 deletions(-)

diff --git a/algorithmic/problems/145/checker.cpp b/algorithmic/problems/145/checker.cpp
index 0843fbb48..a5278762b 100644
--- a/algorithmic/problems/145/checker.cpp
+++ b/algorithmic/problems/145/checker.cpp
@@ -1,6 +1,8 @@
 // checker.cpp
-// C++11 testlib special judge for the Slitherlink-like problem.
-// Fully reproduces behavior of the original Python+Z3 checker.
+// testlib special judge for the Number Loop construction problem.
+// Counts the single loops satisfying every clue of the contestant's puzzle,
+// capped at six, with an exact plug DP over the grid points: the count does
+// not depend on how weakly the clues constrain the board.
 // Requires testlib.h in include path.
 
 #include "testlib.h"
@@ -58,8 +60,6 @@ double score_percent(int solution_count){
     return 50.0 + 50.0 * u;
 }
 
-// helper printing to stderr (like original)
-void eprint(const string &s){ cerr << s << "\n"; }
 void myAssert(bool cond, const string &msg){
     if(!cond) {
         // In SPJ we usually call quitf for WA, but here follow original: print to stderr and exit
@@ -93,405 +93,180 @@ vector<string> readSol(InStream &in){
     return res;
 }
 
-// Edge representation
-struct Edge {
-    bool is_h; // horizontal if true, vertical if false
-    int i, j;  // coordinates: H[i][j] or V[i][j]
-    vector<pair<int,int>> adj_cells;  // adjacent cells (r,c)
-    vector<pair<int,int>> adj_points; // endpoints (pi,pj)
-    int score; // heuristic: number of adjacent numbered cells
-};
-
-vector<Edge> edges;
-int Ecnt;
-
-// Backtracking state
-vector<int> edge_val; // -1 unassigned, 0 false, 1 true
-int cell_assigned_true[N][N];
-int cell_unassigned[N][N];
-int point_deg[N+1][N+1];
-int point_unassigned[N+1][N+1];
-
-struct Change {
-    int type; // 0: edge val, 1: cell_assigned_true, 2: cell_unassigned, 3: point_deg, 4: point_unassigned
-    int a;    // encoded index (edge idx or r*100 + c or pi*100 + pj)
-    int old;
-};
-vector<Change> changes;
-
-void apply_assign(int eidx, int val){
-    // assume edge_val[eidx] == -1
-    changes.push_back({0, eidx, edge_val[eidx]});
-    edge_val[eidx] = val;
-    const Edge &ed = edges[eidx];
-    // adjacent cells
-    for(size_t k=0;k<ed.adj_cells.size();++k){
-        int r = ed.adj_cells[k].first;
-        int c = ed.adj_cells[k].second;
-        changes.push_back({2, r*100 + c, cell_unassigned[r][c]});
-        cell_unassigned[r][c]--;
-        if(val == 1){
-            changes.push_back({1, r*100 + c, cell_assigned_true[r][c]});
-            cell_assigned_true[r][c]++;
-        }
-    }
-    // endpoints
-    for(size_t k=0;k<ed.adj_points.size();++k){
-        int pi = ed.adj_points[k].first;
-        int pj = ed.adj_points[k].second;
-        changes.push_back({4, pi*100 + pj, point_unassigned[pi][pj]});
-        point_unassigned[pi][pj]--;
-        if(val == 1){
-            changes.push_back({3, pi*100 + pj, point_deg[pi][pj]});
-            point_deg[pi][pj]++;
-        }
-    }
+// Loop counting: plug (profile) DP over the (N+1) x (N+1) grid points in
+// row-major order. Point (i, j) decides the edge to its right, H[i][j], and
+// the edge below it, V[i][j]. Before point (i, j) the profile has N+2 slots:
+//   slot k < j : V[i][k], below an already processed point of row i
+//   slot j     : H[i][j-1], entering (i, j) from the left
+//   slot k > j : V[i-1][k-1], entering (i, k-1) from above
+// A slot is 0 (no edge) or an end of an open path, 1 for its left end and 2
+// for its right end, so the slots form a balanced bracket sequence. Cell
+// (r, c) is checked when point (r+1, c) decides its bottom edge; its top edge
+// H[r][c] has left the profile by then, so it is kept as one bit per column.
+// One more bit records that the loop is closed, after which no edge may be
+// added. Every edge set is reached by exactly one path through the DP.
+
+const int P = N + 1;                 // grid points per side
+const int SLOTS = P + 1;
+const int TOP_SHIFT = 2 * SLOTS;     // top-edge bits follow the slots
+const uint64_t PLUG_MASK = (1ULL << TOP_SHIFT) - 1;
+const uint64_t CLOSED = 1ULL << (TOP_SHIFT + N);
+
+int slot_of(uint64_t s, int k){ return (int)((s >> (2 * k)) & 3); }
+
+uint64_t with_slot(uint64_t s, int k, int v){
+    return (s & ~(3ULL << (2 * k))) | ((uint64_t)v << (2 * k));
 }
 
-void rollback_to(int sz){
-    while((int)changes.size() > sz){
-        Change ch = changes.back(); changes.pop_back();
-        if(ch.type == 0){
-            edge_val[ch.a] = ch.old;
-        } else if(ch.type == 1){
-            int r = ch.a / 100, c = ch.a % 100;
-            cell_assigned_true[r][c] = ch.old;
-        } else if(ch.type == 2){
-            int r = ch.a / 100, c = ch.a % 100;
-            cell_unassigned[r][c] = ch.old;
-        } else if(ch.type == 3){
-            int pi = ch.a / 100, pj = ch.a % 100;
-            point_deg[pi][pj] = ch.old;
-        } else if(ch.type == 4){
-            int pi = ch.a / 100, pj = ch.a % 100;
-            point_unassigned[pi][pj] = ch.old;
-        }
+// Slot holding the other end of the path that ends in slot k.
+int matching_slot(uint64_t s, int k){
+    const int own = slot_of(s, k);
+    const int dir = own == 1 ? 1 : -1;
+    int depth = 0;
+    for(int t = k; t >= 0 && t < SLOTS; t += dir){
+        const int v = slot_of(s, t);
+        if(v == 0) continue;
+        depth += v == own ? 1 : -1;
+        if(depth == 0) return t;
     }
-}
-
-// Propagation: enforce cell counts and point degree constraints (0 or 2)
-bool contradiction_check_and_propagate(){
-    bool changed = true;
-    int iter = 0;
-    while(changed){
-        changed = false;
-        iter++;
-        if(iter > 300000) break; // safety
-        // cells
-        for(int r=0;r<N;r++){
-            for(int c=0;c<N;c++){
-                char ch = grid[r][c];
-                if(ch == ' ') continue;
-                int need = ch - '0';
-                int have = cell_assigned_true[r][c];
-                int rem = cell_unassigned[r][c];
-                if(have > need) return false;
-                if(have + rem < need) return false;
-                if(rem == 0){
-                    if(have != need) return false;
-                } else {
-                    if(have == need){
-                        // force remaining adjacent edges false
-                        for(int e=0;e<Ecnt;e++){
-                            if(edge_val[e] != -1) continue;
-                            for(size_t k=0;k<edges[e].adj_cells.size();++k){
-                                if(edges[e].adj_cells[k].first==r && edges[e].adj_cells[k].second==c){
-                                    apply_assign(e, 0);
-                                    changed = true;
-                                    break;
-                                }
-                            }
-                        }
-                    } else if(have + rem == need){
-                        // force remaining adjacent edges true
-                        for(int e=0;e<Ecnt;e++){
-                            if(edge_val[e] != -1) continue;
-                            for(size_t k=0;k<edges[e].adj_cells.size();++k){
-                                if(edges[e].adj_cells[k].first==r && edges[e].adj_cells[k].second==c){
-                                    apply_assign(e, 1);
-                                    changed = true;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // points: degree must be 0 or 2
-        for(int pi=0; pi<=N; ++pi){
-            for(int pj=0; pj<=N; ++pj){
-                int deg = point_deg[pi][pj];
-                int rem = point_unassigned[pi][pj];
-                bool possible0 = (deg <= 0 && 0 <= deg + rem);
-                bool possible2 = (deg <= 2 && 2 <= deg + rem);
-                if(!possible0 && !possible2) return false;
-                if(rem == 0){
-                    if(!(deg == 0 || deg == 2)) return false;
-                } else {
-                    if(possible0 && !possible2){
-                        // only 0 possible -> all remaining edges adjacent must be false
-                        for(int e=0;e<Ecnt;e++){
-                            if(edge_val[e] != -1) continue;
-                            for(size_t k=0;k<edges[e].adj_points.size();++k){
-                                if(edges[e].adj_points[k].first==pi && edges[e].adj_points[k].second==pj){
-                                    apply_assign(e, 0);
-                                    changed = true;
-                                    break;
-                                }
-                            }
-                        }
-                    } else if(!possible0 && possible2){
-                        int need_true = 2 - deg;
-                        if(need_true < 0) return false;
-                        if(need_true == 0){
-                            for(int e=0;e<Ecnt;e++){
-                                if(edge_val[e] != -1) continue;
-                                for(size_t k=0;k<edges[e].adj_points.size();++k){
-                                    if(edges[e].adj_points[k].first==pi && edges[e].adj_points[k].second==pj){
-                                        apply_assign(e, 0);
-                                        changed = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        } else if(need_true == rem){
-                            for(int e=0;e<Ecnt;e++){
-                                if(edge_val[e] != -1) continue;
-                                for(size_t k=0;k<edges[e].adj_points.size();++k){
-                                    if(edges[e].adj_points[k].first==pi && edges[e].adj_points[k].second==pj){
-                                        apply_assign(e, 1);
-                                        changed = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return true;
-}
-
-// branching heuristic: prefer edges adjacent to numbered cells
-int pick_next_edge(){
-    int best = -1;
-    int best_score = -1;
-    for(int e=0;e<Ecnt;e++){
-        if(edge_val[e] != -1) continue;
-        if(edges[e].score > best_score){
-            best_score = edges[e].score;
-            best = e;
-        }
-    }
-    if(best != -1) return best;
-    for(int e=0;e<Ecnt;e++) if(edge_val[e] == -1) return e;
+    quitf(_fail, "Unbalanced plug profile");
     return -1;
 }
 
-// build H/V matrices from edge_val
-void build_hv_from_edges(vector<vector<int>> &H, vector<vector<int>> &V){
-    H.assign(N+1, vector<int>(N,0));
-    V.assign(N, vector<int>(N+1,0));
-    for(int e=0;e<Ecnt;e++){
-        if(edge_val[e] == 1){
-            if(edges[e].is_h) H[edges[e].i][edges[e].j] = 1;
-            else V[edges[e].i][edges[e].j] = 1;
-        }
-    }
+// Clue digit of cell (r, c), or -1 for a blank or out-of-grid cell.
+int clue_at(int r, int c){
+    if(r < 0 || r >= N || c < 0 || c >= N || grid[r][c] == ' ') return -1;
+    return grid[r][c] - '0';
 }
 
-// split assignment into loops (each loop is vector of (tag,i,j))
-vector<vector< tuple<char,int,int> > > split_loops_from_assignment(){
-    vector<vector<int> > H(N+1, vector<int>(N,0));
-    vector<vector<int> > V(N, vector<int>(N+1,0));
-    for(int e=0;e<Ecnt;e++){
-        if(edge_val[e] == 1){
-            if(edges[e].is_h) H[edges[e].i][edges[e].j] = 1;
-            else V[edges[e].i][edges[e].j] = 1;
-        }
+// Map from DP state to its number of ways (at most LIMIT), by open
+// addressing. A hard board reaches about 10^6 states per step, so each entry
+// keeps its count in the high bits of its state word to halve the memory.
+struct StateMap {
+    static constexpr int WAYS_SHIFT = 56;          // states use the bits below
+    static constexpr uint64_t STATE_BITS = (1ULL << WAYS_SHIFT) - 1;
+    static constexpr uint64_t EMPTY = ~0ULL;       // never a valid entry
+    int bits;
+    vector<uint64_t> table;
+    vector<uint32_t> used;                         // occupied entries
+
+    StateMap(){ bits = 0; rehash(16); }
+
+    size_t find(uint64_t state) const {
+        const size_t mask = table.size() - 1;
+        size_t h = (size_t)((state * 0x9E3779B97F4A7C15ULL) >> (64 - bits));
+        while(table[h] != EMPTY && (table[h] & STATE_BITS) != state) h = (h + 1) & mask;
+        return h;
     }
 
-    auto incident_edges_at_point = [&](int pi, int pj){
-        vector< tuple<char,int,int> > res;
-        if(pi>0 && V[pi-1][pj]) res.push_back(make_tuple('v', pi-1, pj));
-        if(pi < N && V[pi][pj]) res.push_back(make_tuple('v', pi, pj));
-        if(pj>0 && H[pi][pj-1]) res.push_back(make_tuple('h', pi, pj-1));
-        if(pj < N && H[pi][pj]) res.push_back(make_tuple('h', pi, pj));
-        return res;
-    };
-
-    auto remove_edge_mat = [&](char tag, int i, int j){
-        if(tag=='h') H[i][j] = 0;
-        else V[i][j] = 0;
-    };
-
-    vector<vector< tuple<char,int,int> > > loop_list;
-
-    while(true){
-        bool found_edge = false;
-        char start_tag = 0;
-        int start_i=-1, start_j=-1;
-        for(int i=0;i<=N && !found_edge;i++){
-            for(int j=0;j<N && !found_edge;j++){
-                if(H[i][j]){ start_tag='h'; start_i=i; start_j=j; found_edge=true; break; }
-            }
+    void rehash(int new_bits){
+        vector<uint64_t> old_table(1ULL << new_bits, EMPTY);
+        vector<uint32_t> old_used;
+        table.swap(old_table);
+        used.swap(old_used);
+        bits = new_bits;
+        for(uint32_t h : old_used){
+            const size_t g = find(state(old_table[h]));
+            table[g] = old_table[h];
+            used.push_back((uint32_t)g);
         }
-        for(int i=0;i<N && !found_edge;i++){
-            for(int j=0;j<=N && !found_edge;j++){
-                if(V[i][j]){ start_tag='v'; start_i=i; start_j=j; found_edge=true; break; }
-            }
-        }
-        if(!found_edge) break;
-
-        int cur_pi = start_i, cur_pj = start_j;
-        vector< tuple<char,int,int> > loop;
-        char prev_tag = 0; int prev_i = -1, prev_j = -1;
-        int init_pi = cur_pi, init_pj = cur_pj;
-        while(true){
-            vector< tuple<char,int,int> > inc = incident_edges_at_point(cur_pi, cur_pj);
-            bool moved = false;
-            for(size_t k=0;k<inc.size();++k){
-                char t = get<0>(inc[k]);
-                int ei = get<1>(inc[k]);
-                int ej = get<2>(inc[k]);
-                if(prev_tag != 0 && t==prev_tag && ei==prev_i && ej==prev_j) continue;
-                loop.push_back(inc[k]);
-                remove_edge_mat(t, ei, ej);
-                // move to other endpoint
-                if(t=='h'){
-                    if(cur_pi==ei && cur_pj==ej){
-                        prev_tag = 'h'; prev_i = ei; prev_j = ej;
-                        cur_pi = ei; cur_pj = ej+1;
-                    } else {
-                        prev_tag = 'h'; prev_i = ei; prev_j = ej;
-                        cur_pi = ei; cur_pj = ej;
-                    }
-                } else {
-                    if(cur_pi==ei && cur_pj==ej){
-                        prev_tag = 'v'; prev_i = ei; prev_j = ej;
-                        cur_pi = ei+1; cur_pj = ej;
-                    } else {
-                        prev_tag = 'v'; prev_i = ei; prev_j = ej;
-                        cur_pi = ei; cur_pj = ej;
-                    }
-                }
-                moved = true;
-                break;
-            }
-            if(!moved) break;
-            if(cur_pi==init_pi && cur_pj==init_pj && !loop.empty()) break;
-        }
-        if(!loop.empty()) loop_list.push_back(loop);
-        else break;
     }
-    return loop_list;
-}
 
-// generate hv/vv from one loop and check against grid
-bool generateSol_from_loop(const vector< tuple<char,int,int> > &loop, vector<vector<int>> &Hout, vector<vector<int>> &Vout){
-    Hout.assign(N+1, vector<int>(N,0));
-    Vout.assign(N, vector<int>(N+1,0));
-    vector<vector<int>> cnt(N, vector<int>(N,0));
-    for(size_t k=0;k<loop.size();++k){
-        char tag = get<0>(loop[k]);
-        int i = get<1>(loop[k]);
-        int j = get<2>(loop[k]);
-        if(tag=='h'){
-            Hout[i][j] = 1;
-            if(i < N) cnt[i][j] += 1;
-            if(i > 0) cnt[i-1][j] += 1;
-        } else {
-            Vout[i][j] = 1;
-            if(j < N) cnt[i][j] += 1;
-            if(j > 0) cnt[i][j-1] += 1;
-        }
+    static uint64_t state(uint64_t entry){ return entry & STATE_BITS; }
+    static int ways(uint64_t entry){ return (int)(entry >> WAYS_SHIFT); }
+
+    // ways[s] += w, capped at limit (below 256, to fit in the entry).
+    void add(uint64_t s, int w, int limit){
+        if(2 * (used.size() + 1) > table.size()) rehash(bits + 1);
+        const size_t h = find(s);
+        int now = w;
+        if(table[h] == EMPTY) used.push_back((uint32_t)h);
+        else now += ways(table[h]);
+        table[h] = s | ((uint64_t)min(limit, now) << WAYS_SHIFT);
     }
-    for(int i=0;i<N;i++){
-        for(int j=0;j<N;j++){
-            if(grid[i][j] != ' '){
-                int need = grid[i][j] - '0';
-                if(cnt[i][j] != need) return false;
-            }
-        }
-    }
-    return true;
-}
 
-// serialize a solution (H,V) to string for deduplication
-string serialize_solution(const vector<vector<int>> &H, const vector<vector<int>> &V){
-    string s;
-    s.reserve((N+1)*N + N*(N+1) + 10);
-    for(int i=0;i<=N;i++){
-        for(int j=0;j<N;j++) s.push_back(H[i][j] ? '1' : '0');
-        s.push_back('|');
-    }
-    s.push_back('#');
-    for(int i=0;i<N;i++){
-        for(int j=0;j<=N;j++) s.push_back(V[i][j] ? '1' : '0');
-        s.push_back('|');
+    int get(uint64_t s) const {
+        const uint64_t entry = table[find(s)];
+        return entry == EMPTY ? 0 : ways(entry);
     }
-    return s;
-}
 
-void print_solution_to_stderr(const vector<vector<int>> &H, const vector<vector<int>> &V){
-    eprint("Sol:");
-    for(int i=0;i<=N;i++){
-        string s = " ";
-        for(int k=0;k<N;k++){
-            s.push_back(H[i][k] ? '-' : ' ');
-            if(k+1<N) s.push_back(' ');
-        }
-        eprint(s);
-        if(i!=N){
-            string s2;
-            for(int p=0;p<=N;p++){
-                s2.push_back(V[i][p] ? '|' : ' ');
-                if(p!=N) s2.push_back(grid[i][p]);
-            }
-            eprint(s2);
-        }
+    void clear(){
+        for(uint32_t h : used) table[h] = EMPTY;
+        used.clear();
     }
-}
+};
+
+// Number of single loops that satisfy every clue, capped at limit.
+int count_solutions(int limit){
+    StateMap cur, nxt;
+    cur.add(0, 1, limit);
+    for(int i = 0; i < P; i++){
+        for(int j = 0; j < P; j++){
+            // Clues of the cells whose edges point (i, j) completes or starts.
+            const int d_done = clue_at(i - 1, j);   // all four edges known
+            const int d_left = clue_at(i, j - 1);   // top, left and right known
+            const int d_here = clue_at(i, j);       // top and left known
+            nxt.clear();
+            for(uint32_t h : cur.used){
+                const uint64_t s = StateMap::state(cur.table[h]);
+                const int ways = StateMap::ways(cur.table[h]);
+                const int L = slot_of(s, j), U = slot_of(s, j + 1);
+                for(int right = 0; right <= 1; right++){
+                    for(int down = 0; down <= 1; down++){
+                        if(right && j == N) continue;
+                        if(down && i == N) continue;
+                        const int deg = (L != 0) + (U != 0) + right + down;
+                        if(deg != 0 && deg != 2) continue;
+                        if(deg != 0 && (s & CLOSED)) continue;
+
+                        if(d_done >= 0){
+                            const int have = (int)((s >> (TOP_SHIFT + j)) & 1) + (U != 0)
+                                           + (slot_of(s, j + 2) != 0) + right;
+                            if(have != d_done) continue;
+                        }
+                        if(d_left >= 0){
+                            const int have = (L != 0) + (slot_of(s, j - 1) != 0) + down;
+                            if(have > d_left || have + 1 < d_left) continue;
+                        }
+                        if(d_here >= 0 && (right + down > d_here || right + down + 2 < d_here)) continue;
+
+                        uint64_t t = with_slot(with_slot(s, j, 0), j + 1, 0);
+                        if(L != 0 && U != 0){
+                            if(L == 1 && U == 1){
+                                t = with_slot(t, matching_slot(s, j + 1), 1);
+                            } else if(L == 2 && U == 2){
+                                t = with_slot(t, matching_slot(s, j), 2);
+                            } else if(L == 1 && U == 2){
+                                // Joining the two ends of one path closes a
+                                // loop, which must then be the only one.
+                                if(t & PLUG_MASK) continue;
+                                t |= CLOSED;
+                            }
+                        } else if(L != 0 || U != 0){
+                            t = with_slot(t, down ? j : j + 1, L | U);
+                        } else if(deg != 0){
+                            t = with_slot(with_slot(t, j, 1), j + 1, 2);
+                        }
 
-// container for unique solutions
-vector<pair<vector<vector<int>>, vector<vector<int>>>> sol_list;
-unordered_set<string> sol_set; // serialized strings for dedup
-
-// recursive search (stop when found >= limit_solutions)
-bool try_search(int limit_solutions){
-    int unassigned = 0;
-    for(int e=0;e<Ecnt;e++) if(edge_val[e] == -1) unassigned++;
-    if(unassigned == 0){
-        // full assignment: split into loops and check each loop individually
-        vector<vector< tuple<char,int,int> > > loops = split_loops_from_assignment();
-        for(size_t i=0;i<loops.size();++i){
-            vector<vector<int>> Hsol, Vsol;
-            if(generateSol_from_loop(loops[i], Hsol, Vsol)){
-                string key = serialize_solution(Hsol, Vsol);
-                if(sol_set.find(key) == sol_set.end()){
-                    sol_set.insert(key);
-                    sol_list.push_back(make_pair(Hsol, Vsol));
-                    if((int)sol_list.size() >= limit_solutions) return true;
+                        if(j < N){
+                            t &= ~(1ULL << (TOP_SHIFT + j));
+                            if(right && d_here >= 0) t |= 1ULL << (TOP_SHIFT + j);
+                        }
+                        nxt.add(t, ways, limit);
+                    }
                 }
             }
+            swap(cur, nxt);
         }
-        return false;
-    }
-    int e = pick_next_edge();
-    if(e == -1) return false;
-    for(int val = 0; val <= 1; ++val){
-        int save_sz = (int)changes.size();
-        apply_assign(e, val);
-        bool ok = contradiction_check_and_propagate();
-        if(ok){
-            if(try_search(limit_solutions)) return true;
+        // Next row: every slot moves one to the right and slot 0 opens empty.
+        nxt.clear();
+        for(uint32_t h : cur.used){
+            const uint64_t s = StateMap::state(cur.table[h]);
+            nxt.add((s & ~PLUG_MASK) | ((s << 2) & PLUG_MASK), StateMap::ways(cur.table[h]), limit);
         }
-        rollback_to(save_sz);
+        swap(cur, nxt);
     }
-    return false;
+    return cur.get(CLOSED);
 }
 
 int main(int argc, char **argv){
@@ -505,80 +280,14 @@ int main(int argc, char **argv){
     // read contestant output (ouf) as grid grid
     grid = readSol(ouf);
 
-    // build edge list
-    edges.clear();
-    // horizontals H[0..12][0..11]
-    for(int i=0;i<=N;i++){
-        for(int j=0;j<N;j++){
-            Edge ed;
-            ed.is_h = true; ed.i = i; ed.j = j; ed.score = 0;
-            if(i>0) ed.adj_cells.push_back(make_pair(i-1,j));
-            if(i<N) ed.adj_cells.push_back(make_pair(i,j));
-            ed.adj_points.push_back(make_pair(i,j));
-            ed.adj_points.push_back(make_pair(i,j+1));
-            for(size_t k=0;k<ed.adj_cells.size();++k){
-                int r = ed.adj_cells[k].first, c = ed.adj_cells[k].second;
-                if(grid[r][c] != ' ') ed.score++;
-            }
-            edges.push_back(ed);
-        }
-    }
-    // verticals V[0..11][0..12]
-    for(int i=0;i<N;i++){
-        for(int j=0;j<=N;j++){
-            Edge ed;
-            ed.is_h = false; ed.i = i; ed.j = j; ed.score = 0;
-            if(j>0) ed.adj_cells.push_back(make_pair(i,j-1));
-            if(j<N) ed.adj_cells.push_back(make_pair(i,j));
-            ed.adj_points.push_back(make_pair(i,j));
-            ed.adj_points.push_back(make_pair(i+1,j));
-            for(size_t k=0;k<ed.adj_cells.size();++k){
-                int r = ed.adj_cells[k].first, c = ed.adj_cells[k].second;
-                if(grid[r][c] != ' ') ed.score++;
-            }
-            edges.push_back(ed);
-        }
-    }
-    Ecnt = (int)edges.size();
-
-    // initialize state
-    edge_val.assign(Ecnt, -1);
-    for(int i=0;i<N;i++) for(int j=0;j<N;j++){
-        cell_assigned_true[i][j] = 0;
-        cell_unassigned[i][j] = 4;
-    }
-    for(int i=0;i<=N;i++) for(int j=0;j<=N;j++){
-        point_deg[i][j] = 0;
-        int t = 0;
-        if(i!=0) t++;
-        if(i!=N) t++;
-        if(j!=0) t++;
-        if(j!=N) t++;
-        point_unassigned[i][j] = t;
-    }
-
-    // run initial propagation
-    if(!contradiction_check_and_propagate()){
-        // no valid assignment at all
-        quitp(0.0, "There is no valid solution");
-    }
-
-    // Enumerate solutions, stopping once the score bucket is known.
-    sol_list.clear();
-    sol_set.clear();
+    // Count solutions up to the cap that fixes the score bucket.
     const int LIMIT = 6;
-    try_search(LIMIT);
-
-    int cnt = (int)sol_list.size();
+    const int cnt = count_solutions(LIMIT);
 
     if(cnt == 0){
         quitp(0.0, "There is no valid solution");
     }
 
-    for(int k=0;k< (int)min((size_t)6, sol_list.size()); ++k) {
-        print_solution_to_stderr(sol_list[k].first, sol_list[k].second);
-    }
-
     const int ones = count_ones();
     const int clues = clue_cell_count();
     const double score = score_percent(cnt);