multi-puzzle-solver 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

{multi_puzzle_solver-1.0.6.dist-info → multi_puzzle_solver-1.0.7.dist-info}/RECORD

@@ -1,7 +1,8 @@
-puzzle_solver/__init__.py,sha256=OBCEdCUd7-i81fEAhMa5DSirGbfhID5IwVk1jTkNxC4,5298
+puzzle_solver/__init__.py,sha256=CiplXqjf9w0kuDmtvive0gM8hkZEIRQNgaK1A_X_ZwE,5390
 puzzle_solver/core/utils.py,sha256=FE0106dfQRsgCn2FRBvRq5zILLK7-Z3cPHkAlBWUX0w,8785
 puzzle_solver/core/utils_ortools.py,sha256=ACV3HgKWpEUTt1lpqsPryK1DeZpu7kdWQKEWTLJ2tfs,10384
 puzzle_solver/core/utils_visualizer.py,sha256=AmVeBuEMaJzVY2zBbRoONlC9x3AGLKcdaNn8mD-nrLs,23347
+puzzle_solver/puzzles/abc_view/abc_view.py,sha256=Qr0rZKmKQ2teStHjQ5VPQ4k-XptsjJAlZ1WXWk5Aax4,4570
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=dGqYEWMoh4di5DN4sd-GtYb6QeTpVYFQJHBkrrmrudQ,5649
 puzzle_solver/puzzles/battleships/battleships.py,sha256=U4xJ_NJC2baHvfaAfJ01YEBjixq9gD0h8GP9L1V-_oM,7223
 puzzle_solver/puzzles/binairo/binairo.py,sha256=qKvpixLIBUcugAyJgpBGHV-9q_4nzA1ZOxeDFnltsXA,6843
@@ -21,7 +22,7 @@ puzzle_solver/puzzles/flood_it/parse_map/parse_map.py,sha256=m7gcpvN3THZdYLowdR_
 puzzle_solver/puzzles/galaxies/galaxies.py,sha256=IiKPU3fz5Aokhj5OjeT5jd_vdNuWnLzjZylGOTepsNU,5600
 puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=XmFqVN_oRfq9AZFWy5ViUJ2Szjgx-srrRkFPJXEEyFo,9358
 puzzle_solver/puzzles/guess/guess.py,sha256=MpyrF6YVu0S1fzX-BllwxGKRGacWJpeLbNn5GetuEyo,10792
-puzzle_solver/puzzles/heyawake/heyawake.py,sha256=U0nWSX8SMDmaLwA0K555ru_mMX2MLjCiZVNSz8T0Ksg,5687
+puzzle_solver/puzzles/heyawake/heyawake.py,sha256=cBD0xHYvVOBAOiwAB_K9sjf1Hv3zL4GBiq1Dml27F6g,9085
 puzzle_solver/puzzles/inertia/inertia.py,sha256=-Y5fr7aK20zwmGHsZql7pYCq1kyMZglvkVZ6uIDf1HA,5658
 puzzle_solver/puzzles/inertia/tsp.py,sha256=mAhlSjCWespASeN8uLZ0JkYDw-ZqFEpal6NM-ubpCXw,15313
 puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=x0d64gTBd0HC2lO5uOpX2VKWfwj8rRiz0mQM_lqNmWs,8457
@@ -38,13 +39,13 @@ puzzle_solver/puzzles/nonograms/nonograms.py,sha256=Q-VHI0IPR2igccnE617HPThj5tnB
 puzzle_solver/puzzles/nonograms/nonograms_colored.py,sha256=Qy3CGNNs0MoZQv-qHyMMP8-fK7s7f_utK-Rc1hQaX_A,10750
 puzzle_solver/puzzles/norinori/norinori.py,sha256=ZEDWrD7zvEuqXOdXGOrELh1n_mWzhzZa3chs6Zqd3Pc,4570
 puzzle_solver/puzzles/nurikabe/nurikabe.py,sha256=hX0VcjPwO8PfY2kiIpQV45FWIvKRosFebk588tp5wzk,6603
-puzzle_solver/puzzles/palisade/palisade.py,sha256=q_uQbp6Ef0RXcELMX97msurQk_F53_AlZdEfKVq-NlI,5075
+puzzle_solver/puzzles/palisade/palisade.py,sha256=Stvgw0k_sml9Dj5RMRVf0EmU5a_eGf1fn65IXelR6Wk,4802
 puzzle_solver/puzzles/pearl/pearl.py,sha256=slPVCzPObQLNk4EYqe55YR4JeRCUs07Mjdks1fWKZSY,6696
 puzzle_solver/puzzles/pipes/pipes.py,sha256=2HDHCWhD-fLYTRoJsx15gOrsgt_SbjlGF2QDS5UX6m8,4680
 puzzle_solver/puzzles/range/range.py,sha256=sJVMKzoT5unihMKurriAUTGLY0f7OQXSZfSHWezPPkw,3387
 puzzle_solver/puzzles/rectangles/rectangles.py,sha256=6MuJHyw7woIljlqxt76zfhw8F2_2biKMFM7oiXdXZsg,7010
 puzzle_solver/puzzles/shakashaka/shakashaka.py,sha256=PRpg_qI7XA3ysAo_g1TRJsT3VwB5Vial2UcFyBOMwKQ,9571
-puzzle_solver/puzzles/shingoki/shingoki.py,sha256=u-r6nLlF4WAlSUsQxNMjaPPdojFOIe7eJgiSgLa883s,7496
+puzzle_solver/puzzles/shingoki/shingoki.py,sha256=Sra6i4kpVzIK6CabhK9yDVDLBuZiNS4daPimtnTgQu0,6777
 puzzle_solver/puzzles/signpost/signpost.py,sha256=38LlMvP5Fx4qrTXmw4aNCt3yUbG3fhdSk6-YXmhAHFg,3861
 puzzle_solver/puzzles/singles/singles.py,sha256=AugO2Gnd_OEyrxXUnqg3oPypdmeiFais_fu19-gm4Eg,2945
 puzzle_solver/puzzles/slant/slant.py,sha256=l4q9g0BfqQsA6zsySiemJC5iFsqsO6LoqTUqcTEqYEk,5897
@@ -67,7 +68,7 @@ puzzle_solver/puzzles/unruly/unruly.py,sha256=_C6FhYm9rqwhlQa6TMTxYr3rWcP_QS-E93
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=D0JacUdK5yPrfScmGqX-p8144VbwxfDgIaqF8hwLXlM,5039
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=T2g5We9J3tkhyXWoN2OrIDIJDjt6w5sDd2ksOub0ZI8,6819
-multi_puzzle_solver-1.0.6.dist-info/METADATA,sha256=L-BnSETryC5gEqJYM6b-bSm2iGPkvJYWg47lHzRiwSw,450669
-multi_puzzle_solver-1.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-1.0.6.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-1.0.6.dist-info/RECORD,,
+multi_puzzle_solver-1.0.7.dist-info/METADATA,sha256=WfWXNWvZZPMkq8SmkWShIMpG6S4dDZcvayWDFIyM9-A,452620
+multi_puzzle_solver-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-1.0.7.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-1.0.7.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -1,3 +1,4 @@
+from puzzle_solver.puzzles.abc_view import abc_view as abc_view_solver
 from puzzle_solver.puzzles.aquarium import aquarium as aquarium_solver
 from puzzle_solver.puzzles.battleships import battleships as battleships_solver
 from puzzle_solver.puzzles.binairo import binairo as binairo_solver
@@ -58,6 +59,7 @@ from puzzle_solver.puzzles.yin_yang import yin_yang as yin_yang_solver
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
 __all__ = [
+    abc_view_solver,
     aquarium_solver,
     battleships_solver,
     binairo_solver,
@@ -117,4 +119,4 @@ __all__ = [
     inertia_image_parser,
 ]
 
-__version__ = '1.0.6'
+__version__ = '1.0.7'

puzzle_solver/puzzles/abc_view/abc_view.py

@@ -0,0 +1,75 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array, top: np.array, left: np.array, bottom: np.array, right: np.array, characters: list[str]):
+        self.BLANK = 'BLANK'
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.characters_no_blank = characters
+        self.characters = characters + [self.BLANK]
+        assert all(c.strip() in self.characters or c.strip() == '' for c in board.flatten()), f'board must contain characters in {self.characters}'
+        assert all(c.strip() in self.characters or c.strip() == '' for c in np.concatenate([top, left, bottom, right])), f'top, bottom, left, and right must contain only characters in {self.characters}'
+        self.board = board
+        self.V, self.H = board.shape
+        assert top.shape == (self.H,) and bottom.shape == (self.H,) and left.shape == (self.V,) and right.shape == (self.V,), 'top, bottom, left, and right must be 1d arrays of length board width and height'
+        self.top = top
+        self.left = left
+        self.bottom = bottom
+        self.right = right
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for character in self.characters:
+                self.model_vars[pos, character] = self.model.NewBoolVar(f'{pos}:{character}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne([self.model_vars[pos, character] for character in self.characters])
+            c = get_char(self.board, pos).strip()  # force the clue if on the board
+            if not c:
+                continue
+            self.model.Add(self.model_vars[pos, c] == 1)
+
+        # each row and column must have exactly one of each character, except for BLANK
+        for row in range(self.V):
+            for character in self.characters_no_blank:
+                self.model.AddExactlyOne([self.model_vars[pos, character] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):
+            for character in self.characters_no_blank:
+                self.model.AddExactlyOne([self.model_vars[pos, character] for pos in get_col_pos(col, self.V)])
+
+        # a character clue on that side means the first character that appears on the side is the clue
+        for i, top_char in enumerate(self.top):
+            self.force_first_character(list(get_col_pos(i, self.V)), top_char)
+        for i, bottom_char in enumerate(self.bottom):
+            self.force_first_character(list(get_col_pos(i, self.V))[::-1], bottom_char)
+        for i, left_char in enumerate(self.left):
+            self.force_first_character(list(get_row_pos(i, self.H)), left_char)
+        for i, right_char in enumerate(self.right):
+            self.force_first_character(list(get_row_pos(i, self.H))[::-1], right_char)
+
+    def force_first_character(self, pos_list: list[Pos], target_character: str):
+        if not target_character:
+            return
+        for i, pos in enumerate(pos_list):
+            is_first_char = self.model.NewBoolVar(f'{i}:{target_character}:is_first_char')
+            and_constraint(self.model, is_first_char, [self.model_vars[pos, self.BLANK] for pos in pos_list[:i]] + [self.model_vars[pos_list[i], self.BLANK].Not()])
+            self.model.Add(self.model_vars[pos, target_character] == 1).OnlyEnforceIf(is_first_char)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: char for (pos, char), var in board.model_vars.items() if solver.Value(var) == 1 and char != board.BLANK})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), ''), text_on_shaded_cells=False))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/heyawake/heyawake.py

@@ -1,9 +1,9 @@
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_pos, get_char
+from puzzle_solver.core.utils import Pos, get_all_pos, get_col_pos, get_neighbors4, get_pos, get_char, get_row_pos
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-from puzzle_solver.core.utils_visualizer import combined_function
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
 def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
@@ -20,6 +20,17 @@ def return_3_consecutives(int_list: list[int]) -> list[tuple[int, int]]:
         out.append((begin_idx, end_idx))
     return out
 
+
+def get_diagonal(pos1: Pos, pos2: Pos) -> list[Pos]:
+    assert pos1 != pos2, 'positions must be different'
+    dx = pos1.x - pos2.x
+    dy = pos1.y - pos2.y
+    assert abs(dx) == abs(dy), 'positions must be on a diagonal'
+    sdx = 1 if dx > 0 else -1
+    sdy = 1 if dy > 0 else -1
+    return [get_pos(x=pos2.x + i*sdx, y=pos2.y + i*sdy) for i in range(abs(dx) + 1)]
+
+
 class Board:
     def __init__(self, board: np.array, region_to_clue: dict[str, int]):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
@@ -59,6 +70,10 @@ class Board:
         force_connected_component(self.model, self.W)
         # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
         self.disallow_white_lines_spanning_3_regions()
+        # straight diagonal black lines from side wall to horizontal wall are not allowed; because they would disconnect the white cells
+        self.disallow_full_black_diagonal()
+        # disallow a diagonal black line coming out of a wall of length N then coming back in on the same wall; because it would disconnect the white cells
+        self.disallow_zigzag_on_wall()
 
     def disallow_white_lines_spanning_3_regions(self):
         # A straight (orthogonal) line of connected white cells cannot span across more than 2 regions.
@@ -77,22 +92,61 @@ class Board:
                 pos_list = [get_pos(x=col_num, y=y) for y in range(begin_idx, end_idx+1)]
                 self.model.AddBoolOr([self.B[p] for p in pos_list])
 
-    def solve_and_print(self, verbose: bool = True):
+    def disallow_full_black_diagonal(self):
+        corners_dx_dy = [
+            ((0, 0), 1, 1),
+            ((self.H-1, 0), -1, 1),
+            ((0, self.V-1), 1, -1),
+            ((self.H-1, self.V-1), -1, -1),
+        ]
+        for (corner_x, corner_y), dx, dy in corners_dx_dy:
+            for delta in range(1, min(self.V, self.H)):
+                pos1 = get_pos(x=corner_x, y=corner_y + delta*dy)
+                pos2 = get_pos(x=corner_x + delta*dx, y=corner_y)
+                diagonal_line = get_diagonal(pos1, pos2)
+                self.model.AddBoolOr([self.W[p] for p in diagonal_line])
+
+    def disallow_zigzag_on_wall(self):
+        for pos in get_row_pos(0, self.H):  # top line
+            for end_x in range(pos.x + 2, self.H, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=end_x, y=pos.y)
+                dx = end_x - pos.x
+                mid_pos = get_pos(x=pos.x + dx//2, y=pos.y + dx//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from top wall to bottom triangle tip "\"
+                diag_2 = get_diagonal(end_pos, mid_pos)  # from bottom triangle tip to top wall "/"
+                self.model.AddBoolOr([self.W[p] for p in diag_1 + diag_2])
+        for pos in get_row_pos(self.V-1, self.H):  # bottom line
+            for end_x in range(pos.x + 2, self.H, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=end_x, y=pos.y)
+                dx = end_x - pos.x
+                mid_pos = get_pos(x=pos.x + dx//2, y=pos.y - dx//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from bottom wall to top triangle tip "/"
+                diag_2 = get_diagonal(end_pos, mid_pos)  # from top triangle tip to bottom wall "\"
+                self.model.AddBoolOr([self.W[p] for p in diag_1 + diag_2])
+        for pos in get_col_pos(0, self.V):  # left line
+            for end_y in range(pos.y + 2, self.V, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=pos.x, y=end_y)
+                dy = end_y - pos.y
+                mid_pos = get_pos(x=pos.x + dy//2, y=pos.y + dy//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from left wall to right triangle tip "\"
+                diag_2 = get_diagonal(end_pos, mid_pos)  # from right triangle tip to left wall "/"
+                self.model.AddBoolOr([self.W[p] for p in diag_1 + diag_2])
+        for pos in get_col_pos(self.H-1, self.V):  # right line
+            for end_y in range(pos.y + 2, self.V, 2):  # end pos is even distance away from start pos
+                end_pos = get_pos(x=pos.x, y=end_y)
+                dy = end_y - pos.y
+                mid_pos = get_pos(x=pos.x - dy//2, y=pos.y + dy//2)
+                diag_1 = get_diagonal(pos, mid_pos)  # from right wall to left triangle tip "/"
+
+    def solve_and_print(self, verbose: bool = True, max_solutions: int = 20):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for pos, var in board.B.items():
-                assignment[pos] = 1 if solver.Value(var) == 1 else 0
-            return SingleSolution(assignment=assignment)
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.B.items()})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            # res = np.full((self.V, self.H), ' ', dtype=object)
-            # for pos in get_all_pos(self.V, self.H):
-            #     c = 'B' if single_res.assignment[pos] == 1 else ' '
-            #     set_char(res, pos, c)
-            # print(res)
             print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
                 is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1,
                 center_char=lambda r, c: self.region_to_clue.get(int(self.board[r, c]), ''),
                 text_on_shaded_cells=False
             ))
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=1)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/palisade/palisade.py

@@ -9,9 +9,7 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
 from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
 
 
-
-# a shape on the 2d board is just a set of positions
-Shape = frozenset[Pos]
+Shape = frozenset[Pos]  # a shape on the 2d board is just a set of positions
 
 @dataclass(frozen=True)
 class ShapeOnBoard:
@@ -36,7 +34,6 @@ def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
     # min x/y is always 0
     max_x = max(p[0] for p in shape_list)
     max_y = max(p[1] for p in shape_list)
-
     for dy in range(0, board.shape[0] - max_y):
         for dx in range(0, board.shape[1] - max_x):
             body = tuple((p[0] + dx, p[1] + dy) for p in shape_list)
@@ -48,7 +45,6 @@ def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
                 yield frozenset(get_pos(x=p[0], y=p[1]) for p in body)
 
 
-
 class Board:
     def __init__(self, board: np.array, region_size: int):
         assert region_size >= 1 and isinstance(region_size, int), 'region_size must be an integer greater than or equal to 1'
@@ -59,7 +55,6 @@ class Board:
         self.region_size = region_size
         self.region_count = (self.V * self.H) // self.region_size
         assert self.region_count * self.region_size == self.V * self.H, f'region_size must be a factor of the board size, got {self.region_size} and {self.region_count}'
-
         self.polyominoes = polyominoes(self.region_size)
 
         self.model = cp_model.CpModel()
@@ -74,9 +69,7 @@ class Board:
                 uid = len(self.shapes_on_board)
                 shape_on_board = ShapeOnBoard(
                     is_active=self.model.NewBoolVar(f'{uid}:is_active'),
-                    shape=shape,
-                    shape_id=uid,
-                    body=body,
+                    shape=shape, shape_id=uid, body=body
                 )
                 self.shapes_on_board.append(shape_on_board)
                 for pos in body:
@@ -88,19 +81,11 @@ class Board:
 
     def solve_and_print(self, verbose: bool = True):
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[Pos, int] = {}
-            for shape in board.shapes_on_board:
-                if solver.Value(shape.is_active) == 1:
-                    for pos in shape.body:
-                        assignment[pos] = shape.shape_id
-            return SingleSolution(assignment=assignment)
+            active_shapes = [shape for shape in board.shapes_on_board if solver.Value(shape.is_active) == 1]
+            return SingleSolution(assignment={pos: shape.shape_id for shape in active_shapes for pos in shape.body})
         def callback(single_res: SingleSolution):
             print("Solution found")
-            id_board = np.full((self.V, self.H), ' ', dtype=object)
-            for pos in get_all_pos(self.V, self.H):
-                region_idx = single_res.assignment[pos]
-                set_char(id_board, pos, region_idx)
             print(combined_function(self.V, self.H,
-                cell_flags=id_board_to_wall_fn(id_board),
+                cell_flags=id_board_to_wall_fn(np.array([[single_res.assignment[get_pos(x=c, y=r)] for c in range(self.H)] for r in range(self.V)])),
                 center_char=lambda r, c: self.board[r, c] if self.board[r, c] != ' ' else '·'))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -1,35 +1,20 @@
-import json
-from dataclasses import dataclass
-import time
+from collections import defaultdict
 
 import numpy as np
 from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_neighbors4, get_next_pos, get_char, in_bounds
-from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_char, in_bounds, set_char, get_pos, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, force_connected_component, and_constraint, SingleSolution
 from puzzle_solver.core.utils_visualizer import combined_function
 
 
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[tuple[Pos, Pos], int]
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for (pos, neighbor), v in self.assignment.items():
-            result.append((pos.x, pos.y, neighbor.x, neighbor.y, v))
-        return json.dumps(result, sort_keys=True)
-
-
-def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[tuple[Pos, Pos]]:
+def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
     out = []
-    prev_pos = pos
     while True:
+        out.append(pos)
         pos = get_next_pos(pos, direction)
         if not in_bounds(pos, V, H):
             break
-        out.append((prev_pos, pos))
-        prev_pos = pos
     return out
 
 
@@ -37,8 +22,8 @@ class Board:
     def __init__(self, board: np.array):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
         assert all((c.item().strip() == '') or (str(c.item())[:-1].isdecimal() and c.item()[-1].upper() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only space or digits and B/W'
-
         self.V, self.H = board.shape
+        self.board = board
         self.board_numbers: dict[Pos, int] = {}
         self.board_colors: dict[Pos, str] = {}
         for pos in get_all_pos(self.V, self.H):
@@ -47,112 +32,84 @@ class Board:
                 continue
             self.board_numbers[pos] = int(c[:-1])
             self.board_colors[pos] = c[-1].upper()
+
         self.model = cp_model.CpModel()
-        self.edge_vars: dict[tuple[Pos, Pos], cp_model.IntVar] = {}
+        self.cell_active: dict[Pos, cp_model.IntVar] = {}
+        self.cell_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
 
         self.create_vars()
         self.add_all_constraints()
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
-            for neighbor in get_neighbors4(pos, self.V, self.H):
-                if (neighbor, pos) in self.edge_vars:  # already added in opposite direction
-                    self.edge_vars[(pos, neighbor)] = self.edge_vars[(neighbor, pos)]
-                else:  # new edge
-                    self.edge_vars[(pos, neighbor)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
+            self.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
+            for direction in Direction:
+                neighbor = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    self.cell_direction[(pos, direction)] = self.model.NewConstant(0)
+                    continue
+                if (neighbor, opposite_direction) in self.cell_direction:
+                    self.cell_direction[(pos, direction)] = self.cell_direction[(neighbor, opposite_direction)]
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
 
     def add_all_constraints(self):
-        # each corners must have either 0 or 2 neighbors
-        for pos in get_all_pos(self.V, self.H):
-            corner_connections = [self.edge_vars[(pos, n)] for n in get_neighbors4(pos, self.V, self.H)]
-            if pos not in self.board_numbers:  # no color, either 0 or 2 edges
-                self.model.AddLinearExpressionInDomain(sum(corner_connections), cp_model.Domain.FromValues([0, 2]))
-            else:  # color, must have exactly 2 edges
-                self.model.Add(sum(corner_connections) == 2)
-
-        # enforce colors
         for pos in get_all_pos(self.V, self.H):
+            s = sum([self.cell_direction[(pos, direction)] for direction in Direction])
+            self.model.Add(s == 2).OnlyEnforceIf(self.cell_active[pos])
+            self.model.Add(s == 0).OnlyEnforceIf(self.cell_active[pos].Not())
             if pos not in self.board_numbers:
                 continue
-            self.enforce_corner_color(pos, self.board_colors[pos])
-            self.enforce_corner_number(pos, self.board_numbers[pos])
-
-        # enforce single connected component
-        def is_neighbor(edge1: tuple[Pos, Pos], edge2: tuple[Pos, Pos]) -> bool:
-            return any(c1 == c2 for c1 in edge1 for c2 in edge2)
-        force_connected_component(self.model, self.edge_vars, is_neighbor=is_neighbor)
+            self.enforce_corner_color_and_number(pos, self.board_colors[pos], self.board_numbers[pos])  # enforce colors and number
+        self.force_connected_component()  # enforce single connected component
 
-    def enforce_corner_color(self, pos: Pos, pos_color: str):
-        assert pos_color in ['W', 'B'], f'Invalid color: {pos_color}'
-        pos_r = get_next_pos(pos, Direction.RIGHT)
-        var_r = self.edge_vars[(pos, pos_r)] if (pos, pos_r) in self.edge_vars else False
-        pos_d = get_next_pos(pos, Direction.DOWN)
-        var_d = self.edge_vars[(pos, pos_d)] if (pos, pos_d) in self.edge_vars else False
-        pos_l = get_next_pos(pos, Direction.LEFT)
-        var_l = self.edge_vars[(pos, pos_l)] if (pos, pos_l) in self.edge_vars else False
-        pos_u = get_next_pos(pos, Direction.UP)
-        var_u = self.edge_vars[(pos, pos_u)] if (pos, pos_u) in self.edge_vars else False
+    def enforce_corner_color_and_number(self, pos: Pos, pos_color: str, pos_number: int):
+        assert pos_color in ['W', 'B'] and pos_number > 0, f'Invalid color or number: {pos_color}, {pos_number}'
+        self.model.Add(self.cell_active[pos] == 1)
         if pos_color == 'W':  # White circles must be passed through in a straight line
-            self.model.Add(var_r == var_l)
-            self.model.Add(var_u == var_d)
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == self.cell_direction[(pos, Direction.LEFT)])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == self.cell_direction[(pos, Direction.UP)])
         elif pos_color == 'B':  # Black circles must be turned upon
-            self.model.Add(var_r == 0).OnlyEnforceIf([var_l])
-            self.model.Add(var_l == 0).OnlyEnforceIf([var_r])
-            self.model.Add(var_u == 0).OnlyEnforceIf([var_d])
-            self.model.Add(var_d == 0).OnlyEnforceIf([var_u])
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.LEFT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.RIGHT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.UP)]])
+            self.model.Add(self.cell_direction[(pos, Direction.UP)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.DOWN)]])
         else:
             raise ValueError(f'Invalid color: {pos_color}')
-
-    def enforce_corner_number(self, pos: Pos, pos_number: int):
-        # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
-        # Build visibility chains per direction (exclude self)
-        vis_vars: list[cp_model.IntVar] = []
-        for direction in Direction:
-            rays = get_ray(pos, self.V, self.H, direction)  # cells outward
-            if not rays:
-                continue
-            # Chain: v0 = w[ray[0]]; vt = w[ray[t]] & vt-1
-            prev = None
-            for idx, (pos1, pos2) in enumerate(rays):
-                v = self.model.NewBoolVar(f"vis[{pos1}-{pos2}]->({direction.name})[{idx}]")
+        vis_vars: list[cp_model.IntVar] = []  # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, self.V, self.H, direction)  # cells outward
+            for idx in range(len(ray)):
+                v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                and_constraint(self.model, target=v, cs=[self.cell_direction[(p, direction)] for p in ray[:idx+1]])
                 vis_vars.append(v)
-                if idx == 0:
-                    # v0 == w[cell]
-                    self.model.Add(v == self.edge_vars[(pos1, pos2)])
-                else:
-                    and_constraint(self.model, target=v, cs=[self.edge_vars[(pos1, pos2)], prev])
-                prev = v
         self.model.Add(sum(vis_vars) == pos_number)
 
+    def force_connected_component(self):
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if p1 == p2 and d1 != d2:  # same position, different direction, is neighbor
+                return True
+            if get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1):
+                return True
+            return False
+        force_connected_component(self.model, self.cell_direction, is_neighbor=is_neighbor)
 
     def solve_and_print(self, verbose: bool = True):
-        tic = time.time()
         def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
-            assignment: dict[tuple[Pos, Pos], int] = {}
-            for (pos, neighbor), var in board.edge_vars.items():
-                assignment[(pos, neighbor)] = solver.Value(var)
+            assignment: dict[Pos, str] = defaultdict(str)
+            for (pos, direction), var in board.cell_direction.items():
+                assignment[pos] += direction.name[0] if solver.BooleanValue(var) else ''
             return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
-            nonlocal tic
-            print(f"Solution found in {time.time() - tic:.2f} seconds")
-            tic = time.time()
-            res = np.full((self.V - 1, self.H - 1), ' ', dtype=object)
-            for (pos, neighbor), v in single_res.assignment.items():
-                if v == 0:
-                    continue
-                min_x = min(pos.x, neighbor.x)
-                min_y = min(pos.y, neighbor.y)
-                dx = abs(pos.x - neighbor.x)
-                dy = abs(pos.y - neighbor.y)
-                if min_x == self.H - 1:  # only way to get right
-                    res[min_y][min_x - 1] += 'R'
-                elif min_y == self.V - 1:  # only way to get down
-                    res[min_y - 1][min_x] += 'D'
-                elif dx == 1:
-                    res[min_y][min_x] += 'U'
-                elif dy == 1:
-                    res[min_y][min_x] += 'L'
-                else:
-                    raise ValueError(f'Invalid position: {pos} and {neighbor}')
-            print(combined_function(self.V - 1, self.H - 1, cell_flags=lambda r, c: res[r, c], center_char=lambda r, c: '.'))
+            print("Solution found")
+            output_board = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if get_char(self.board, pos)[-1] in ['B', 'W']:  # if the main board has a white or black pearl, put it in the output
+                    set_char(output_board, pos, get_char(self.board, pos))
+                if not single_res.assignment[pos].strip():  # if the cell does not the line through it, put a dot
+                    set_char(output_board, pos, '.')
+            print(combined_function(self.V, self.H, show_grid=False, special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)], center_char=lambda r, c: output_board[r, c]))
         return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)