multi-puzzle-solver 1.1.8__py3-none-any.whl

puzzle_solver/puzzles/circle_9/circle_9.py

@@ -0,0 +1,44 @@
+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 generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() == ' ') or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.N = max(self.V, self.H)
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            if get_char(self.board, pos).strip():
+                self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        for v in range(1, self.N + 1):  # each digit is circled once
+            self.model.AddExactlyOne([self.model_vars[pos] for pos in get_all_pos(self.V, self.H) if get_char(self.board, pos) == str(v)])
+        for row in range(self.V):  # each row contains 1 circle
+            self.model.AddExactlyOne([self.model_vars[pos] for pos in get_row_pos(row, self.H) if pos in self.model_vars])
+        for col in range(self.H):  # each column contains 1 circle
+            self.model.AddExactlyOne([self.model_vars[pos] for pos in get_col_pos(col, self.V) if pos in self.model_vars])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                cell_flags=lambda r, c: 'ULRD' if single_res.assignment.get(get_pos(x=c, y=r), 0) == 1 else '',
+                center_char=lambda r, c: self.board[r, c].strip() if self.board[r, c].strip() else '.',
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/clouds/clouds.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    body: frozenset[Pos]
+    is_active: cp_model.IntVar
+    disallow: frozenset[Pos]
+
+
+class Board:
+    def __init__(self, side: np.array, top: np.array):
+        self.V = side.shape[0]
+        self.H = top.shape[0]
+        self.side = side
+        self.top = top
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.shapes_on_board: set[ShapeOnBoard] = set()
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for x in range(0, self.H):
+            for end_x in range(x, self.H + 1):
+                if (end_x - x) < 2:
+                    continue
+                max_allowed_height = np.min(self.top[x:end_x])
+                for y in range(0, self.V):
+                    for end_y in range(y, self.V + 1):
+                        if (end_y - y) < 2 or (end_y - y) > max_allowed_height:
+                            continue
+                        max_allowed_width = np.min(self.side[y:end_y])
+                        if (end_x - x) > max_allowed_width:
+                            continue
+                        body = frozenset(get_pos(x=i, y=j) for i in range(x, end_x) for j in range(y, end_y))
+                        disallow = frozenset(get_pos(x=i, y=j) for i in range(x-1, end_x+1) for j in range(y-1, end_y+1)) - body
+                        self.shapes_on_board.add(ShapeOnBoard(
+                            body=body,
+                            is_active=self.model.NewBoolVar(f'{x}-{y}-{end_x}-{end_y}-is_active'),
+                            disallow=disallow
+                        ))
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        # if a piece is active then all its body is active and the disallow is inactive
+        for shape in self.shapes_on_board:
+            for pos in shape.body:
+                self.model.Add(self.model_vars[pos] == 1).OnlyEnforceIf(shape.is_active)
+            for pos in shape.disallow:
+                if pos not in self.model_vars:
+                    continue
+                self.model.Add(self.model_vars[pos] == 0).OnlyEnforceIf(shape.is_active)
+        # if a spot is active then exactly one piece (with a body there) is active
+        for pos in get_all_pos(self.V, self.H):
+            pieces_on_pos = [shape for shape in self.shapes_on_board if pos in shape.body]
+            # if pos is on then exactly one shape is active. if pos is off then 0 shapes are active.
+            self.model.Add(lxp.Sum([shape.is_active for shape in pieces_on_pos]) == self.model_vars[pos])
+        for row in range(self.V):  # force side counts
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in get_row_pos(row, self.H)]) == self.side[row])
+        for col in range(self.H):  # force top counts
+            self.model.Add(lxp.Sum([self.model_vars[pos] for pos in get_col_pos(col, self.V)]) == self.top[col])
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/connect_the_dots/connect_the_dots.py

@@ -0,0 +1,50 @@
+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_neighbors4
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+        self.unique_colors = set([str(c.item()).strip() for c in np.nditer(board) if str(c.item()).strip() not in ['', '#']])
+        assert all(np.count_nonzero(board == color) == 2 for color in self.unique_colors), f'each color must appear == 2 times, got {self.unique_colors}'
+        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 color in self.unique_colors:
+                self.model_vars[(pos, color)] = self.model.NewBoolVar(f'{pos}:{color}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos).strip()
+            if c == '#':  # a wall, thus no color
+                self.model.Add(sum([self.model_vars[(pos, color)] for color in self.unique_colors]) == 0)
+                continue
+            self.model.AddExactlyOne([self.model_vars[(pos, color)] for color in self.unique_colors])
+            if c != '':  # an endpoint, thus must be the color
+                self.model.Add(self.model_vars[(pos, c)] == 1)
+                self.model.Add(sum([self.model_vars[(n, c)] for n in get_neighbors4(pos, self.V, self.H)]) == 1)  # endpoints must have exactly 1 neighbor
+            else:  # not an endpoint, thus must have exactly 2 neighbors
+                for color in self.unique_colors:
+                    self.model.Add(sum([self.model_vars[(n, color)] for n in get_neighbors4(pos, self.V, self.H)]) == 2).OnlyEnforceIf(self.model_vars[(pos, color)])
+        for color in self.unique_colors:
+            force_connected_component(self.model, {pos: self.model_vars[(pos, color)] for pos in get_all_pos(self.V, self.H)})
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: color for (pos, color), var in board.model_vars.items() if solver.Value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(np.array([[single_res.assignment.get(get_pos(x=c, y=r), '') for c in range(self.H)] for r in range(self.V)])),
+                center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), self.board[r, c])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/cow_and_cactus/cow_and_cactus.py

@@ -0,0 +1,66 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, Direction, get_char, get_ray
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+class Board:
+    def __init__(self, board: np.ndarray):
+        assert board.ndim == 2 and board.shape[0] > 0 and board.shape[1] > 0, f'board must be 2d, got {board.ndim}'
+        assert all(str(i.item()).strip() in ['', 'W', 'P'] or str(i.item()).strip().isdecimal() for i in np.nditer(board)), f'board must be empty or a W or a P or a number, got {list(np.nditer(board))}'
+        self.V, self.H = board.shape
+        self.board = board
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.outside_fence: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f"{pos}")
+            self.outside_fence[pos] = self.model_vars[pos].Not()
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = str(get_char(self.board, pos)).strip()
+            if c == '':
+                continue
+            elif c in ['W', 'P']:  # cow or cactus
+                self.model.Add(self.model_vars[pos] == (c == 'W'))
+            else:
+                self.range_clue(pos, int(c))
+        force_connected_component(self.model, self.model_vars)
+        def is_outside_neighbor(p1: Pos, p2: Pos) -> bool:
+            if abs(p1.x - p2.x) + abs(p1.y - p2.y) == 1:  # manhattan distance is 1
+                return True
+            # both are on the border
+            p1_on_border = p1.x == 0 or p1.x == self.H- 1 or p1.y == 0 or p1.y == self.V - 1
+            p2_on_border = p2.x == 0 or p2.x == self.H- 1 or p2.y == 0 or p2.y == self.V - 1
+            return p1_on_border and p2_on_border
+        force_connected_component(self.model, self.outside_fence, is_neighbor=is_outside_neighbor)
+
+    def range_clue(self, pos: Pos, c: int):
+        self.model.Add(self.model_vars[pos] == 1)  # Force it white
+        vis_vars: list[cp_model.IntVar] = []
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, direction, self.V, self.H)  # 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.model_vars[p] for p in ray[:idx+1]])
+                vis_vars.append(v)
+        self.model.Add(1 + sum(vis_vars) == int(c))  # Sum of visible whites = 1 (itself) + sum(chains) == k
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(board.model_vars[pos]) for pos in get_all_pos(board.V, board.H)})
+        def callback(single_res: SingleSolution):
+            print("Solution:")
+            print(combined_function(self.V, self.H,
+            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].strip(),
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/dominosa/dominosa.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+from collections import defaultdict
+from typing import Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, Direction, get_next_pos, in_bounds, get_pos
+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
+
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    uid: str
+    is_active: cp_model.IntVar
+
+
+class Board:
+    def __init__(self, board: np.array, target_pairs: Optional[list[tuple[int, int]]] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(str(i.item()).isdecimal() for i in np.nditer(board)), 'board must contain only digits'
+        self.board = board
+        self.V, self.H = board.shape
+        self.target_pairs = target_pairs
+        if target_pairs is None:
+            nums = [int(i.item()) for i in np.nditer(board)]
+            assert min(nums) == 0, 'expected board to start from 0'
+            self.target_pairs = [(i, j) for i in range(max(nums) + 1) for j in range(i, max(nums) + 1)]
+
+        self.model = cp_model.CpModel()
+        self.pair_to_shapes: dict[tuple[int, int], set[ShapeOnBoard]] = defaultdict(set)
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                next_pos = get_next_pos(pos, direction)
+                if not in_bounds(next_pos, self.V, self.H):
+                    continue
+                c1 = int(get_char(self.board, pos))
+                c2 = int(get_char(self.board, next_pos))
+                pair = tuple(sorted((c1, c2)))
+                uid = f'{pos.x}-{pos.y}-{direction.name[0]}'
+                s = ShapeOnBoard(uid=uid, is_active=self.model.NewBoolVar(uid))
+                self.pair_to_shapes[pair].add(s)
+                self.pos_to_shapes[pos].add(s)
+                self.pos_to_shapes[next_pos].add(s)
+
+    def add_all_constraints(self):
+        for pair in self.target_pairs:  # exactly one shape active for each pair
+            self.model.AddExactlyOne(s.is_active for s in self.pair_to_shapes[pair])
+        for pos in get_all_pos(self.V, self.H):  # at most one shape active at each position
+            self.model.AddAtMostOne(s.is_active for s in self.pos_to_shapes[pos])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: s.uid for pos in get_all_pos(self.V, self.H) for s in self.pos_to_shapes[pos] if solver.Value(s.is_active) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                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: str(self.board[r, c])
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/filling/filling.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+
+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, polyominoes, in_bounds, get_next_pos, Direction
+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
+
+
+@dataclass
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    N: int
+    body: set[Pos]
+    disallow_same_shape: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.ndarray, digits = (1, 2, 3, 4, 5, 6, 7, 8, 9)):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+        assert all((c == ' ') or (str(c).isdecimal() and 0 <= int(c) <= 9) for c in np.nditer(board)), "board must contain space or digits 0..9"
+        self.digits = digits
+        self.polyominoes = {d: polyominoes(d) for d in self.digits}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.digit_to_shapes = {d: [] for d in self.digits}
+        self.body_loc_to_shape = {(d,p): [] for d in self.digits for p in get_all_pos(self.V, self.H)}
+        self.forced_pos: dict[Pos, int] = {}
+
+        self.create_vars()
+        self.force_hints()
+        self.init_polyominoes_on_board()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for d in self.digits:
+                self.model_vars[(d,pos)] = self.model.NewBoolVar(f'{d}:{pos}')
+
+    def force_hints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c.isdecimal():
+                self.model.Add(self.model_vars[(int(c),pos)] == 1)
+                self.forced_pos[pos] = int(c)
+
+    def init_polyominoes_on_board(self):
+        for d in self.digits:  # all digits
+            digit_count = 0
+            for pos in get_all_pos(self.V, self.H):  # translate by shape
+                for shape in self.polyominoes[d]:  # all shapes of d digits
+                    body = {pos + p for p in shape}
+                    if any(not in_bounds(p, self.V, self.H) for p in body):
+                        continue
+                    if any(p in self.forced_pos and self.forced_pos[p] != d for p in body):  # part of this shape's body is already forced to a different digit, skip
+                        continue
+                    disallow_same_shape = set(get_next_pos(p, direction) for p in body for direction in Direction)
+                    disallow_same_shape = {p for p in disallow_same_shape if p not in body and in_bounds(p, self.V, self.H)}
+                    shape_on_board = ShapeOnBoard(
+                        is_active=self.model.NewBoolVar(f'd{d}:{digit_count}:{pos}:is_active'),
+                        N=d,
+                        body=body,
+                        disallow_same_shape=disallow_same_shape,
+                    )
+                    self.digit_to_shapes[d].append(shape_on_board)
+                    for p in body:
+                        self.body_loc_to_shape[(d,p)].append(shape_on_board)
+                    digit_count += 1
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model.AddExactlyOne(self.model_vars[(d,pos)] for d in self.digits)  # exactly one digit is active at every position
+            self.model.AddExactlyOne(s.is_active for d in self.digits for s in self.body_loc_to_shape[(d,pos)])  # exactly one shape is active at that position
+        for s_list in self.body_loc_to_shape.values():  # if a shape is active then all its body is active
+            for s in s_list:
+                for p in s.body:
+                    self.model.Add(self.model_vars[(s.N,p)] == 1).OnlyEnforceIf(s.is_active)
+        for d, s_list in self.digit_to_shapes.items():  # same shape cannot touch each other
+            for s in s_list:
+                for disallow_pos in s.disallow_same_shape:
+                    self.model.Add(self.model_vars[(d,disallow_pos)] == 0).OnlyEnforceIf(s.is_active)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: "Board", solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: d for pos in get_all_pos(self.V, self.H) for d in self.digits if solver.Value(self.model_vars[(d,pos)]) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res_arr = np.array([[single_res.assignment[get_pos(x=c, y=r)] for c in range(self.H)] for r in range(self.V)])
+            print(combined_function(self.V, self.H, cell_flags=id_board_to_wall_fn(res_arr), center_char=lambda r, c: res_arr[r, c]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/flip/flip.py

@@ -0,0 +1,64 @@
+from typing import Any, Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_char, Direction, get_next_pos, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def _to_pos(pos: Pos, s: str) -> Pos:
+    d = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN}[s[0]]
+    r = get_next_pos(pos, d)
+    if len(s) == 1:
+        return r
+    else:
+        return _to_pos(r, s[1:])
+
+
+class Board:
+    def __init__(self, board: np.array, random_mapping: Optional[dict[Pos, Any]] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only B or W'
+        self.board = board
+        self.V, self.H = board.shape
+        if random_mapping is None:
+            self.tap_mapping: dict[Pos, set[Pos]] = {pos: list(get_neighbors4(pos, self.V, self.H, include_self=True)) for pos in get_all_pos(self.V, self.H)}
+        else:
+            mapping_value = list(random_mapping.values())[0]
+            if isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], Pos):
+                self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
+            elif isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], str):  # strings like "L", "UR", etc.
+                self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(_to_pos(pos, s) for s in random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
+            else:
+                raise ValueError(f'invalid random_mapping: {random_mapping}')
+            for k, v in self.tap_mapping.items():
+                if k not in v:
+                    v.add(k)
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'tap:{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            # the state of a position is its starting state + if it is tapped + if any pos pointing to it is tapped
+            pos_that_will_turn_me = [k for k,v in self.tap_mapping.items() if pos in v]
+            literals = [self.model_vars[p] for p in pos_that_will_turn_me]
+            if get_char(self.board, pos) == 'W':  # if started as white then needs an even number of taps while xor checks for odd number
+                literals.append(self.model.NewConstant(True))
+            self.model.AddBoolXOr(literals)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/flood_it/flood_it.py

@@ -0,0 +1,174 @@
+import sys
+import time
+from collections import defaultdict
+from typing import Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, get_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, nodes: dict[int, int], edges: dict[int, set[int]], horizon: int, start_node_id: int):
+        self.T = horizon
+        self.nodes = nodes
+        self.edges = edges
+        self.start_node_id = start_node_id
+        self.K = len(set(nodes.values()))
+
+        self.model = cp_model.CpModel()
+        self.decision: dict[tuple[int, int], cp_model.IntVar] = {}  # (t, k)
+        self.connected: dict[tuple[int, int], cp_model.IntVar] = {}  # (t, cluster_id)
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for t in range(self.T - 1):  # (N-1) actions (we dont need to decide at time N)
+            for k in range(self.K):
+                self.decision[t, k] = self.model.NewBoolVar(f'decision:{t}:{k}')
+        for t in range(self.T):
+            for cluster_id in self.nodes:
+                self.connected[t, cluster_id] = self.model.NewBoolVar(f'connected:{t}:{cluster_id}')
+
+    def add_all_constraints(self):
+        # init time t=0, all clusters are not connected except start_node
+        for cluster_id in self.nodes:
+            if cluster_id == self.start_node_id:
+                self.model.Add(self.connected[0, cluster_id] == 1)
+            else:
+                self.model.Add(self.connected[0, cluster_id] == 0)
+        # each timestep I will pick either one or zero colors
+        for t in range(self.T - 1):
+            # print('fixing decision at time t=', t, 'to single action with colors', self.K)
+            self.model.Add(lxp.sum([self.decision[t, k] for k in range(self.K)]) <= 1)
+        # at the end of the game, all clusters must be connected
+        for cluster_id in self.nodes:
+            self.model.Add(self.connected[self.T-1, cluster_id] == 1)
+
+        for t in range(1, self.T):
+            for cluster_id in self.nodes:
+                # connected[t, i] must be 0 if all connencted clusters at t-1 are 0 (thus connected[t, i] <= sum(connected[t-1, j] for j in touching)
+                sum_neighbors = lxp.sum([self.connected[t-1, j] for j in self.edges[cluster_id]]) + self.connected[t-1, cluster_id]
+                self.model.Add(self.connected[t, cluster_id] <= sum_neighbors)
+                # connected[t, i] must be 0 if color chosen at time t does not match color of cluster i and not connected at t-1
+                cluster_color = self.nodes[cluster_id]
+                self.model.Add(self.connected[t, cluster_id] == 0).OnlyEnforceIf([self.decision[t-1, cluster_color].Not(), self.connected[t-1, cluster_id].Not()])
+                self.model.Add(self.connected[t, cluster_id] == 1).OnlyEnforceIf([self.connected[t-1, cluster_id]])
+
+        pairs = [(self.decision[t, k], t+1) for t in range(self.T - 1) for k in range(self.K)]
+        self.model.Minimize(lxp.weighted_sum([p[0] for p in pairs], [p[1] for p in pairs]))
+
+    def solve(self) -> list[SingleSolution]:
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: list[str] = [None for _ in range(self.T - 1)]
+            for t in range(self.T - 1):
+                for k in range(self.K):
+                    if solver.Value(self.decision[t, k]) == 1:
+                        assignment[t] = k
+                        break
+            return SingleSolution(assignment=assignment)
+        return generic_solve_all(self, board_to_solution, verbose=False, max_solutions=1)
+
+
+def solve_minimum_steps(board: np.array, start_pos: Optional[Pos] = None, verbose: bool = True) -> int:
+    tic = time.time()
+    all_colors: set[str] = {c.item().strip() for c in np.nditer(board) if c.item().strip()}
+    color_to_int: dict[str, int] = {c: i for i, c in enumerate(sorted(all_colors))}  # colors string to color id
+    int_to_color: dict[int, str] = {i: c for c, i in color_to_int.items()}
+
+    graph: dict[Pos, int] = _board_to_graph(board)  # position to cluster id
+    nodes: dict[int, int] = {cluster_id: color_to_int[get_char(board, pos)] for pos, cluster_id in graph.items()}
+    edges = _graph_to_edges(board, graph)  # cluster id to touching cluster ids
+    if start_pos is None:
+        start_pos = Pos(0,0)
+
+    def solution_int_to_str(solution: SingleSolution):
+        return [int_to_color.get(color_id, '?') for color_id in solution.assignment]
+
+    def print_solution(solution: SingleSolution):
+        solution = solution_int_to_str(solution)
+        print("Solution:", solution)
+    solution = _binary_search_solution(nodes, edges, graph[start_pos], callback=print_solution if verbose else None, verbose=verbose)
+    if verbose:
+        if solution is None:
+            print("No solution found")
+        else:
+            solution = solution_int_to_str(solution)
+            print(f"Best Horizon is: T={len(solution)}")
+            print("Best solution is:", solution)
+        toc = time.time()
+        print(f"Time taken: {toc - tic:.2f} seconds")
+    return solution
+
+
+def _board_to_graph(board: np.array) -> dict[int, set[int]]:
+    def dfs_flood(board: np.array, pos: Pos, cluster_id: int, graph: dict[Pos, int]):
+        if pos in graph:
+            return
+        graph[pos] = cluster_id
+        for neighbor in get_neighbors4(pos, board.shape[0], board.shape[1]):
+            if get_char(board, neighbor) == get_char(board, pos):
+                dfs_flood(board, neighbor, cluster_id, graph)
+    graph: dict[Pos, int] = {}
+    cluster_id = 0
+    V, H = board.shape
+    for pos in get_all_pos(V, H):
+        if pos in graph:
+            continue
+        dfs_flood(board, pos, cluster_id, graph)
+        cluster_id += 1
+    return graph
+
+
+def _graph_to_edges(board: np.array, graph: dict[Pos, int]) -> dict[int, set[int]]:
+    cluster_edges: dict[int, set[int]] = defaultdict(set)
+    V, H = board.shape
+    for pos in get_all_pos(V, H):
+        for neighbor in get_neighbors4(pos, V, H):
+            n1, n2 = graph[pos], graph[neighbor]
+            if n1 != n2:
+                cluster_edges[n1].add(n2)
+                cluster_edges[n2].add(n1)
+    return cluster_edges
+
+
+def _binary_search_solution(nodes, edges, start_node_id, callback, verbose: bool = True):
+    if len(nodes) <= 1:
+        return SingleSolution(assignment=[])
+    min_T = 2
+    max_T = len(nodes)
+    hist = {}  # record historical T and best solution
+    while min_T <= max_T:
+        if max_T - min_T <= 20:  # small gap, just take the middle
+            T = min_T + (max_T - min_T) // 2
+        else:  # large gap, just +5 the min to not go too far
+            T = min_T + 15
+        # main check for binary search
+        if T in hist:  # already done and found solution
+            solutions = hist[T]
+        else:
+            if verbose:
+                print(f"Trying with exactly {T-1} moves...", end='')
+                sys.stdout.flush()
+            binst = Board(nodes=nodes, edges=edges, horizon=T, start_node_id=start_node_id)
+            solutions = binst.solve()
+            if verbose:
+                print(' Possible!' if len(solutions) > 0 else ' Not possible!')
+                if len(solutions) > 0:
+                    callback(solutions[0])
+        if min_T == max_T:
+            hist[T] = solutions
+            break
+        if len(solutions) > 0:
+            hist[T] = solutions
+            max_T = T
+        else:
+            min_T = T + 1
+    best_solution = min(hist.items(), key=lambda x: x[0])[1][0]
+    return best_solution
+
+