multi-puzzle-solver 0.9.10__py3-none-any.whl → 0.9.13__py3-none-any.whl

{multi_puzzle_solver-0.9.10.dist-info → multi_puzzle_solver-0.9.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.10
+Version: 0.9.13
 Summary: Efficient solvers for numerous popular and esoteric logic puzzles using CP-SAT
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver
@@ -259,6 +259,11 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
       <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/star_battle_shapeless_solved.png" alt="Star Battle Shapeless" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#lits-puzzle-type-33"><b>Lits</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/lits_solved.png" alt="Lits" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -306,6 +311,7 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Kakurasu (Puzzle Type #30)](#kakurasu-puzzle-type-30)
   - [Star Battle (Puzzle Type #31)](#star-battle-puzzle-type-31)
   - [Star Battle Shapeless (Puzzle Type #32)](#star-battle-shapeless-puzzle-type-32)
+  - [Lits (Puzzle Type #33)](#lits-puzzle-type-33)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -2687,6 +2693,95 @@ Time taken: 0.02 seconds
 
 ---
 
+## Lits (Puzzle Type #33)
+
+* [**Play online**](https://www.puzzle-lits.com/)
+
+* [**Solver Code**][33]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+ You have to place one tetromino in each region in such a way that:
+- 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
+- The shaded cells should form a single connected area.
+- 2x2 shaded areas are not allowed.
+
+* Tetromino is a shape made of 4 connected cells. There are 5 types of tetrominoes, which are usually named L, I, T, S and O, based on their shape. The O tetromino is not used in this puzzle because it is a 2x2 shape, which is not allowed. 
+
+</details>
+
+Note: The solver is capable of solving variations where the puzzle pieces the made up of more than 4 cells (e.g., pentominoes for 5 with `polyomino_degrees=5`, or hexominoes for 6 with `polyomino_degrees=6`, etc.). By default the degree is set to 4 thus only tetrominoes are used.
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/lits_unsolved.png" alt="Lits unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+board = np.array([
+  ['00', '00', '00', '01', '01', '02', '02', '02', '03', '03', '03', '04', '04', '05', '06', '07', '07', '08', '08', '09'],
+  ['00', '00', '00', '00', '01', '02', '03', '03', '03', '10', '04', '04', '05', '05', '06', '07', '08', '08', '09', '09'],
+  ['11', '11', '11', '01', '01', '02', '02', '03', '10', '10', '04', '04', '05', '06', '06', '07', '07', '07', '09', '12'],
+  ['11', '13', '13', '13', '01', '02', '03', '03', '03', '10', '04', '04', '06', '06', '06', '07', '12', '09', '09', '12'],
+  ['11', '11', '11', '13', '14', '14', '03', '15', '15', '10', '04', '04', '06', '16', '16', '12', '12', '09', '12', '12'],
+  ['17', '13', '13', '13', '14', '14', '03', '03', '15', '15', '04', '04', '16', '16', '16', '12', '12', '12', '12', '18'],
+  ['17', '13', '19', '13', '20', '14', '03', '03', '15', '04', '04', '16', '16', '21', '21', '22', '23', '23', '23', '18'],
+  ['17', '17', '19', '19', '20', '20', '03', '03', '24', '24', '24', '25', '25', '25', '21', '22', '23', '23', '18', '18'],
+  ['17', '26', '19', '19', '20', '20', '20', '24', '24', '20', '20', '25', '25', '21', '21', '22', '22', '23', '23', '18'],
+  ['26', '26', '26', '19', '19', '20', '20', '20', '20', '20', '25', '25', '21', '21', '21', '21', '21', '23', '27', '18'],
+  ['28', '28', '28', '29', '29', '29', '29', '20', '20', '30', '30', '25', '31', '32', '32', '32', '21', '27', '27', '27'],
+  ['28', '33', '28', '28', '28', '28', '29', '34', '34', '35', '30', '30', '31', '31', '31', '32', '32', '36', '36', '27'],
+  ['28', '33', '33', '28', '28', '29', '29', '34', '34', '35', '35', '30', '31', '31', '31', '32', '36', '36', '27', '27'],
+  ['28', '33', '37', '37', '28', '29', '34', '34', '35', '35', '38', '38', '39', '39', '40', '40', '40', '40', '27', '41'],
+  ['28', '37', '37', '37', '42', '34', '34', '34', '43', '38', '38', '38', '39', '39', '44', '44', '40', '40', '27', '41'],
+  ['37', '37', '42', '42', '42', '34', '34', '43', '43', '43', '38', '39', '39', '39', '44', '44', '27', '27', '27', '41'],
+  ['45', '45', '45', '42', '46', '34', '34', '34', '34', '38', '38', '47', '47', '47', '44', '44', '44', '27', '27', '41'],
+  ['48', '45', '45', '46', '46', '46', '46', '34', '49', '49', '49', '47', '44', '44', '44', '27', '44', '50', '27', '27'],
+  ['48', '48', '45', '46', '46', '51', '46', '52', '52', '49', '49', '53', '44', '53', '44', '27', '50', '50', '50', '27'],
+  ['48', '51', '51', '51', '51', '51', '52', '52', '52', '49', '53', '53', '53', '53', '44', '27', '27', '27', '27', '27']
+])
+binst = solver.Board(board)
+solutions = binst.solve_then_constrain()  # solve_then_constrain NOT solve_and_print (to use #1 instead of #2 in https://github.com/google/or-tools/discussions/3347, its faster in this case)
+```
+
+**Script Output**
+
+```python
+Solution found
+[
+  ['X', 'X', 'X', ' ', ' ', 'X', 'X', 'X', ' ', ' ', ' ', ' ', ' ', 'X', ' ', 'X', ' ', 'X', 'X', ' '],
+  [' ', 'X', ' ', ' ', 'X', 'X', ' ', ' ', ' ', 'X', ' ', ' ', 'X', 'X', ' ', 'X', 'X', 'X', ' ', ' '],
+  ['X', 'X', 'X', 'X', 'X', ' ', ' ', 'X', 'X', 'X', ' ', ' ', 'X', ' ', ' ', 'X', ' ', ' ', 'X', ' '],
+  ['X', ' ', ' ', ' ', 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', 'X', ' ', 'X', 'X', ' '],
+  [' ', ' ', ' ', 'X', 'X', 'X', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ', ' ', ' ', 'X', ' ', ' '],
+  ['X', ' ', 'X', 'X', ' ', 'X', ' ', ' ', 'X', 'X', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', 'X', ' '],
+  ['X', ' ', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', 'X', 'X', ' ', ' ', 'X', ' ', ' ', ' ', 'X'],
+  ['X', 'X', ' ', 'X', ' ', 'X', ' ', ' ', 'X', 'X', ' ', 'X', ' ', ' ', ' ', 'X', ' ', 'X', ' ', 'X'],
+  [' ', 'X', ' ', 'X', ' ', 'X', 'X', 'X', 'X', ' ', ' ', 'X', ' ', 'X', 'X', 'X', 'X', 'X', 'X', 'X'],
+  ['X', 'X', 'X', 'X', 'X', 'X', ' ', ' ', ' ', ' ', 'X', 'X', 'X', 'X', ' ', ' ', ' ', 'X', ' ', 'X'],
+  [' ', ' ', ' ', ' ', ' ', 'X', 'X', ' ', ' ', ' ', 'X', ' ', ' ', 'X', 'X', 'X', ' ', ' ', ' ', ' '],
+  [' ', 'X', ' ', 'X', 'X', ' ', 'X', ' ', ' ', 'X', 'X', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'X', ' '],
+  [' ', 'X', 'X', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', 'X', 'X', 'X', ' ', 'X', 'X', ' ', ' '],
+  [' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', ' ', 'X'],
+  [' ', 'X', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', ' ', 'X', 'X', ' ', ' ', 'X', ' ', ' ', 'X'],
+  ['X', 'X', ' ', 'X', 'X', ' ', 'X', 'X', 'X', 'X', 'X', ' ', ' ', 'X', ' ', ' ', 'X', 'X', ' ', 'X'],
+  [' ', 'X', 'X', 'X', ' ', ' ', 'X', ' ', ' ', ' ', 'X', 'X', 'X', 'X', 'X', ' ', ' ', 'X', 'X', 'X'],
+  ['X', ' ', 'X', ' ', 'X', 'X', 'X', ' ', 'X', 'X', ' ', 'X', ' ', ' ', 'X', ' ', ' ', 'X', ' ', ' '],
+  ['X', 'X', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', ' ', 'X', ' ', ' ', 'X', ' ', 'X', 'X', 'X', ' '],
+  ['X', ' ', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', ' ', 'X', ' ', ' ', ' ', ' ', ' '],
+]
+Solutions found: 1
+Time taken: 0.38 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/lits_solved.png" alt="Lits solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -2770,3 +2865,4 @@ Issues and PRs welcome!
 [30]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/kakurasu "puzzle_solver/src/puzzle_solver/puzzles/kakurasu at master · Ar-Kareem/puzzle_solver · GitHub"
 [31]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/star_battle "puzzle_solver/src/puzzle_solver/puzzles/star_battle at master · Ar-Kareem/puzzle_solver · GitHub"
 [32]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/star_battle_shapeless "puzzle_solver/src/puzzle_solver/puzzles/star_battle_shapeless at master · Ar-Kareem/puzzle_solver · GitHub"
+[33]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/lits "puzzle_solver/src/puzzle_solver/puzzles/lits at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.10.dist-info → multi_puzzle_solver-0.9.13.dist-info}/RECORD

@@ -1,8 +1,8 @@
-puzzle_solver/__init__.py,sha256=lETqp2Sgt2ua_j16Zp1WEE88el9-kz3Yah79K4--SEg,2370
-puzzle_solver/core/utils.py,sha256=3LlBDuie_G0uSlzibpQS2ULmEYSZmpJXh1kawj7rjkg,3396
-puzzle_solver/core/utils_ortools.py,sha256=qLTIzmITqmgGZvg8XpYAZ4c-lhD5sEDQfS8ECdQ_dkM,3005
+puzzle_solver/__init__.py,sha256=3aQDyvMPWTlYKDo3j-v4x_lUcNbp7KyallMChQEeJY0,2429
+puzzle_solver/core/utils.py,sha256=D7enPxJjnsTbGDqqtOtGaRaetwGs0nqrNtTnrqhMB-g,3408
+puzzle_solver/core/utils_ortools.py,sha256=eoT9hSJe-c67A_hsu1jnMpyRgMrTtUs5n2j_m5Hk8Do,7362
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
-puzzle_solver/puzzles/battleships/battleships.py,sha256=J1Y-zG2TOmJePCwQnUF8uE9cXL5v8GDVEGv30bQls6k,7467
+puzzle_solver/puzzles/battleships/battleships.py,sha256=6cYFHnOH7RYLfH5DFVz6SRPHY5GauB9YN4hPU7YNUHU,7444
 puzzle_solver/puzzles/bridges/bridges.py,sha256=15A9uV4xjoqPRo_9CTnoKeGRxS3z2aMF619T1n0dTOQ,5402
 puzzle_solver/puzzles/chess_range/chess_melee.py,sha256=D-_Oi8OyxsVe1j3dIKYwRlxgeb3NWLmDWGcv-oclY0c,195
 puzzle_solver/puzzles/chess_range/chess_range.py,sha256=uMQGTIwzGskHIhI-tPYjT9a3wHUBIkZ18eXjV9IpUE4,21071
@@ -17,11 +17,13 @@ puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=A9JQTNqamUdzlwqks0XQ
 puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
 puzzle_solver/puzzles/keen/keen.py,sha256=tDb6C5S3Q0JAKPsdw-84WQ6PxRADELZHr_BK8FDH-NA,5039
 puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
+puzzle_solver/puzzles/lits/lits.py,sha256=gYAcsuWucSer2JWs5eKOroiVmjfi-VzccmZvBIUIFks,12014
 puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
 puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy3us,2582
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_WwAcaeUFuoi5_eqH8U2Og,5876
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=1jmDTOCnmivmBlwtMDyyk3TVqH5IjapzLn7zLQ4qubk,6056
+puzzle_solver/puzzles/norinori/norinori.py,sha256=Z2c0iEn7a6S6gaaJlvNMNNbAQwpztNLB0LTH_XVgu74,12269
 puzzle_solver/puzzles/pearl/pearl.py,sha256=AP0whWwwZ-1zKingW14OwseYylNAr6NkXSrvdnPU6Rw,8566
 puzzle_solver/puzzles/range/range.py,sha256=g6ZuHuulYLpNFsqbnPoIB5KoGPllYppU10-Zzqfj5f8,6993
 puzzle_solver/puzzles/signpost/signpost.py,sha256=-0_S6ycwzwlUf9-ZhP127Rgo5gMBOHiTM6t08dLLDac,3869
@@ -29,7 +31,7 @@ puzzle_solver/puzzles/singles/singles.py,sha256=kwMENfqQ-OP3YIz5baY6LRcvYCsNfhIm
 puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0Nl_xlXXSHvJKw8K1EuE,3718
 puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
 puzzle_solver/puzzles/stitches/stitches.py,sha256=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
-puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=kbxTtJlfmE1IEA8Km3rALsfKXFl-0io1vd3d0Z-0OVo,8984
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=VWHT-iYDaFsd37h9DE07EkeZ_dJMEfatXSByqC2vh04,8916
 puzzle_solver/puzzles/sudoku/sudoku.py,sha256=M_pry7XyKKzlfCF5rFi02lyOrj5GWZzXnDAxmD3NXvI,3588
 puzzle_solver/puzzles/tents/tents.py,sha256=iyVK2WXfIT5j_9qqlQg0WmwvixwXlZSsHGK3XA-KpII,6283
 puzzle_solver/puzzles/thermometers/thermometers.py,sha256=nsvJZkm7G8FALT27bpaB0lv5E_AWawqmvapQI8QcYXw,4015
@@ -37,8 +39,8 @@ puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFB
 puzzle_solver/puzzles/tracks/tracks.py,sha256=0K1YZMHiRIMmFwoD_JxB2c_xB6GYV8spgNUCL-JwDJM,9073
 puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehcwseCarerM,6604
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
-puzzle_solver/utils/visualizer.py,sha256=2LmNoxEqb9PGWmBmHW6jh6OqFgNYguavhHB-9Dv5EUw,6113
-multi_puzzle_solver-0.9.10.dist-info/METADATA,sha256=i3hIJF1eUrTp9KHEO0d-e4KuIxZcrxRKSIzDZDRATCI,136364
-multi_puzzle_solver-0.9.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.10.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.10.dist-info/RECORD,,
+puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
+multi_puzzle_solver-0.9.13.dist-info/METADATA,sha256=x82w11xGJo2Rb4cGGQkmlbQNZ1i7MPGuhxCjOyaj61Y,143181
+multi_puzzle_solver-0.9.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.13.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.13.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -16,6 +16,7 @@ from puzzle_solver.puzzles.map import map as map_solver
 from puzzle_solver.puzzles.minesweeper import minesweeper as minesweeper_solver
 from puzzle_solver.puzzles.mosaic import mosaic as mosaic_solver
 from puzzle_solver.puzzles.nonograms import nonograms as nonograms_solver
+from puzzle_solver.puzzles.lits import lits as lits_solver
 from puzzle_solver.puzzles.pearl import pearl as pearl_solver
 from puzzle_solver.puzzles.range import range as range_solver
 from puzzle_solver.puzzles.signpost import signpost as signpost_solver
@@ -33,4 +34,4 @@ from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.10'
+__version__ = '0.9.13'

puzzle_solver/core/utils.py

@@ -21,7 +21,7 @@ class Direction8(Enum):
     DOWN_LEFT = 7
     DOWN_RIGHT = 8
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, order=True)
 class Pos:
     x: int
     y: int

puzzle_solver/core/utils_ortools.py

@@ -79,4 +79,94 @@ def generic_solve_all(board: Any, board_to_solution: Callable[Any, SingleSolutio
         return collector.solutions
     except Exception as e:
         print(e)
-        raise e
+        raise e
+
+
+def manhattan_distance(p1: Pos, p2: Pos) -> int:
+    return abs(p1.x - p2.x) + abs(p1.y - p2.y)
+
+
+def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.IntVar], is_neighbor: Callable[[Any, Any], bool] = None):
+    """
+    Forces a single connected component of the given variables and any abstract function that defines adjacency.
+    Returns a dictionary of new variables that can be used to enforce the connected component constraint.
+    Total new variables: =(3+N)V where N is average number of neighbors, ~7*N*M for N by M 2D grid
+    WARNING: Will make solutions not unique (because the choice of parent is not unique)
+    """
+    if is_neighbor is None:
+        is_neighbor = lambda p1, p2: manhattan_distance(p1, p2) <= 1
+
+    vs = vars_to_force
+    v_count = len(vs)
+    # =V model variables, one for each variable
+    is_root: dict[Pos, cp_model.IntVar] = {}  # =V
+    prefix_zero: dict[Pos, cp_model.IntVar] = {}  # =V
+    node_mtz: dict[Pos, cp_model.IntVar] = {}  # =V
+    # =NV model variables where N is average number of neighbors (with double counting)
+    # for a N by M 2D grid exactly = 4MN-2M-2N [the correction term (-2M-2N) is because the borders have less neighbors]
+    parent: dict[tuple[int, int], cp_model.IntVar] = {}  # =NV
+    prefix_name = "connected_component_"
+    # total = (3+N)V [for N by M 2D grid total is (7MN-2M-2N) or simply ~7*N*M]
+
+    # must enforce some ordering
+    key_to_idx: dict[Pos, int] = {p: i for i, p in enumerate(vs.keys())}
+    idx_to_key: dict[int, Pos] = {i: p for p, i in key_to_idx.items()}
+    keys_in_order = [idx_to_key[i] for i in range(len(key_to_idx))]
+
+    for p in keys_in_order:
+        is_root[p] = model.NewBoolVar(f"{prefix_name}is_root[{p}]")
+        node_mtz[p] = model.NewIntVar(0, v_count - 1, f"{prefix_name}node_mtz[{p}]")
+    # Unique root: the smallest index i with x[i] = 1
+    # prefix_zero[i] = AND_{k < i} (not x[k])
+    prev_p = None
+    for p in keys_in_order:
+        b = model.NewBoolVar(f"{prefix_name}prefix_zero[{p}]")
+        prefix_zero[p] = b
+        if prev_p is None:  # No earlier cells -> True
+            model.Add(b == 1)
+        else:
+            # b <-> (prefix_zero[i-1] & ~x[i-1])
+            and_constraint(model, b, [prefix_zero[prev_p], vs[prev_p].Not()])
+        prev_p = p
+
+    # x[i] & prefix_zero[i] -> root[i]
+    for p in keys_in_order:
+        and_constraint(model, is_root[p], [vs[p], prefix_zero[p]])
+    # Exactly one root:
+    model.Add(sum(is_root.values()) == 1)
+
+    # For each node i, consider only neighbors
+    for i, pi in enumerate(keys_in_order):
+        cand = sorted([pj for j, pj in enumerate(keys_in_order) if i != j and is_neighbor(pi, pj)])
+        # if a node is active and its not root, it must have 1 parent [the first true candidate], otherwise no parent
+        ps = []
+        for j, pj in enumerate(cand):
+            parent_ij = model.NewBoolVar(f"{prefix_name}parent[{pi},{pj}]")
+            parent[(pi,pj)] = parent_ij
+            am_i_root = is_root[pi]
+            am_i_active = vs[pi]
+            is_neighbor_active = vs[pj]
+            model.AddImplication(parent_ij, am_i_root.Not())
+            model.AddImplication(parent_ij, am_i_active)
+            model.AddImplication(parent_ij, is_neighbor_active)
+            ps.append(parent_ij)
+        # if 1 then sum(parents) = 1, if 0 then sum(parents) = 0; thus sum(parents) = var_minus_root
+        var_minus_root = vs[pi] - is_root[pi]
+        model.Add(sum(ps) == var_minus_root)
+        # MTZ constraint to force single connected component
+        model.Add(node_mtz[pi] == 0).OnlyEnforceIf(is_root[pi])
+        model.Add(node_mtz[pi] == 0).OnlyEnforceIf(vs[pi].Not())
+        for pj in cand:
+            model.Add(node_mtz[pi] == node_mtz[pj] + 1).OnlyEnforceIf(parent[(pi,pj)])
+
+    all_new_vars: dict[str, cp_model.IntVar] = {}
+    for k, v in is_root.items():
+        all_new_vars[f"{prefix_name}is_root[{k}]"] = v
+    for k, v in prefix_zero.items():
+        all_new_vars[f"{prefix_name}prefix_zero[{k}]"] = v
+    for (p1, p2), v in parent.items():
+        all_new_vars[f"{prefix_name}parent[{p1},{p2}]"] = v
+    for k, v in node_mtz.items():
+        all_new_vars[f"{prefix_name}node_mtz[{k}]"] = v
+
+    return all_new_vars

puzzle_solver/puzzles/battleships/battleships.py

@@ -1,4 +1,3 @@
-from enum import Enum
 from dataclasses import dataclass, field
 from typing import Optional
 import numpy as np

puzzle_solver/puzzles/lits/lits.py

@@ -0,0 +1,255 @@
+import json
+import time
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from ortools.sat.python import cp_model
+import numpy as np
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+# a shape on the 2d board is just a set of positions
+Shape = frozenset[Pos]
+
+
+def polyominoes(N):
+    """Generate all polyominoes of size N. Every rotation and reflection is considered different and included in the result.
+    Translation is not considered different and is removed from the result (otherwise the result would be infinite).
+
+    Below is the number of unique polyominoes of size N (not including rotations and reflections) and the lenth of the returned result (which includes all rotations and reflections)
+    N	name		#shapes		#results
+    1	monomino	1			1
+    2	domino		1			2
+    3	tromino		2			6
+    4	tetromino	5			19
+    5	pentomino	12			63
+    6	hexomino	35			216
+    7	heptomino	108			760
+    8	octomino	369			2,725
+    9	nonomino	1,285		9,910
+    10	decomino	4,655		36,446
+    11	undecomino	17,073		135,268
+    12	dodecomino	63,600		505,861
+    Source: https://en.wikipedia.org/wiki/Polyomino
+
+    Args:
+        N (int): The size of the polyominoes to generate.
+
+    Returns:
+        set[(frozenset[Pos], int)]: A set of all polyominoes of size N (rotated and reflected up to D4 symmetry) along with a unique ID for each polyomino.
+    """
+    assert N >= 1, 'N cannot be less than 1'
+    # need a frozenset because regular sets are not hashable
+    shapes: set[Shape] = {frozenset({Pos(0, 0)})}
+    for i in range(1, N):
+        next_shapes: set[Shape] = set()
+        for s in shapes:
+            # frontier: all 4-neighbors of existing cells not already in the shape
+            frontier = {get_next_pos(pos, direction)
+                        for pos in s
+                        for direction in Direction
+                        if get_next_pos(pos, direction) not in s}
+            for cell in frontier:
+                t = s | {cell}
+                # normalize by translation only: shift so min x,y is (0,0). This removes translational symmetries.
+                minx = min(pos.x for pos in t)
+                miny = min(pos.y for pos in t)
+                t0 = frozenset(Pos(x=pos.x - minx, y=pos.y - miny) for pos in t)
+                next_shapes.add(t0)
+        shapes = next_shapes
+    # shapes is now complete, now classify up to D4 symmetry (rotations/reflections), translations ignored
+    mats = (
+        ( 1, 0,  0, 1),  # regular
+        (-1, 0,  0, 1),  # reflect about x
+        ( 1, 0,  0,-1),  # reflect about y
+        (-1, 0,  0,-1),  # reflect about x and y
+        # trnaspose then all 4 above
+        ( 0, 1,  1, 0), ( 0, 1, -1, 0), ( 0,-1,  1, 0), ( 0,-1, -1, 0),
+    )
+    # compute canonical representative for each shape (lexicographically smallest normalized transform)
+    shape_to_canon: dict[Shape, tuple[Pos, ...]] = {}
+    for s in shapes:
+        reps: list[tuple[Pos, ...]] = []
+        for a, b, c, d in mats:
+            pts = {Pos(x=a*p.x + b*p.y, y=c*p.x + d*p.y) for p in s}
+            minx = min(p.x for p in pts)
+            miny = min(p.y for p in pts)
+            rep = tuple(sorted(Pos(x=p.x - minx, y=p.y - miny) for p in pts))
+            reps.append(rep)
+        canon = min(reps)
+        shape_to_canon[s] = canon
+
+    canon_set = set(shape_to_canon.values())
+    canon_to_id = {canon: i for i, canon in enumerate(sorted(canon_set))}
+    result = {(s, canon_to_id[shape_to_canon[s]]) for s in shapes}
+    return result
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[Pos, Union[str, int]]
+    all_other_variables: dict
+
+    def get_hashable_solution(self) -> str:
+        result = []
+        for pos, v in self.assignment.items():
+            result.append((pos.x, pos.y, v))
+        return json.dumps(result, sort_keys=True)
+
+
+
+@dataclass
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+    disallow_same_shape: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array, polyomino_degrees: int = 4):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
+        self.board = board
+        self.polyomino_degrees = polyomino_degrees
+        self.polyominoes = polyominoes(self.polyomino_degrees)
+
+        self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
+        self.blocks = {i: set() for i in self.block_numbers}
+        for cell in get_all_pos(self.V, self.H):
+            self.blocks[int(get_char(self.board, cell))].add(cell)
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.connected_components: dict[Pos, cp_model.IntVar] = {}
+        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+
+        self.create_vars()
+        self.init_shapes_on_board()
+        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}')
+        # print('base vars:', len(self.model_vars))
+
+    def init_shapes_on_board(self):
+        for idx, (shape, shape_id) in enumerate(self.polyominoes):
+            for translate in get_all_pos(self.V, self.H):  # body of shape is translated to be at pos
+                body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape}
+                if any(not in_bounds(p, self.V, self.H) for p in body):
+                    continue
+                # shape must be fully contained in one block
+                if len(set(get_char(self.board, p) for p in body)) > 1:
+                    continue
+                # 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
+                disallow_same_shape = set(get_next_pos(p, direction) for p in body for direction in Direction)
+                disallow_same_shape -= body
+                self.shapes_on_board.append(ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{idx}:{translate}:is_active'),
+                    shape=shape,
+                    shape_id=shape_id,
+                    body=body,
+                    disallow_same_shape=disallow_same_shape,
+                ))
+        # print('shapes on board:', len(self.shapes_on_board))
+
+    def add_all_constraints(self):
+        # RULES:
+        # 1- You have to place one tetromino in each region in such a way that:
+        # 2- 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
+        # 3- The shaded cells should form a single connected area.
+        # 4- 2x2 shaded areas are not allowed
+
+        # each cell must be part of a shape, every shape must be fully on the board. Core constraint, otherwise shapes on the board make no sense.
+        self.only_allow_shapes_on_board()
+
+        self.force_one_shape_per_block()  # Rule #1
+        self.disallow_same_shape_touching()  # Rule #2
+        self.fc = force_connected_component(self.model, self.model_vars)  # Rule #3
+        # print('force connected vars:', len(fc))
+        shape_2_by_2 = frozenset({Pos(0, 0), Pos(0, 1), Pos(1, 0), Pos(1, 1)})
+        self.disallow_shape(shape_2_by_2)  # Rule #4
+
+
+    def only_allow_shapes_on_board(self):
+        for shape_on_board in self.shapes_on_board:
+            # if shape is active then all its body cells must be active
+            self.model.Add(sum(self.model_vars[p] for p in shape_on_board.body) == len(shape_on_board.body)).OnlyEnforceIf(shape_on_board.is_active)
+        # each cell must be part of a shape
+        for p in get_all_pos(self.V, self.H):
+            shapes_on_p = [s for s in self.shapes_on_board if p in s.body]
+            self.model.Add(sum(s.is_active for s in shapes_on_p) == 1).OnlyEnforceIf(self.model_vars[p])
+
+    def force_one_shape_per_block(self):
+        # You have to place exactly one tetromino in each region
+        for block_i in self.block_numbers:
+            shapes_on_block = [s for s in self.shapes_on_board if s.body & self.blocks[block_i]]
+            assert all(s.body.issubset(self.blocks[block_i]) for s in shapes_on_block), 'expected all shapes on block to be fully contained in the block'
+            # print(f'shapes on block {block_i} has {len(shapes_on_block)} shapes')
+            self.model.Add(sum(s.is_active for s in shapes_on_block) == 1)
+
+    def disallow_same_shape_touching(self):
+        # if shape is active then it must not touch any other shape of the same type
+        for shape_on_board in self.shapes_on_board:
+            similar_shapes = [s for s in self.shapes_on_board if s.shape_id == shape_on_board.shape_id]
+            for s in similar_shapes:
+                if shape_on_board.disallow_same_shape & s.body:  # this shape disallows having s be on the board
+                    self.model.Add(s.is_active == 0).OnlyEnforceIf(shape_on_board.is_active)
+
+    def disallow_shape(self, shape_to_disallow: Shape):
+        # for every position in the board, force sum of body < len(body)
+        for translate in get_all_pos(self.V, self.H):
+            cur_body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape_to_disallow}
+            if any(not in_bounds(p, self.V, self.H) for p in cur_body):
+                continue
+            self.model.Add(sum(self.model_vars[p] for p in cur_body) < len(cur_body))
+
+
+
+
+    def solve_and_print(self, verbose: bool = True, max_solutions: Optional[int] = None, verbose_callback: Optional[bool] = None):
+        if verbose_callback is None:
+            verbose_callback = verbose
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            all_other_variables = {
+                'fc': {k: solver.Value(v) for k, v in board.fc.items()}
+            }
+            return SingleSolution(assignment=assignment, all_other_variables=all_other_variables)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=str)
+            for pos, val in single_res.assignment.items():
+                c = 'X' if val == 1 else ' '
+                set_char(res, pos, c)
+            print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
+            pass
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)
+
+    def solve_then_constrain(self, verbose: bool = True):
+        tic = time.time()
+        all_solutions = []
+        while True:
+            solutions = self.solve_and_print(verbose=False, verbose_callback=verbose, max_solutions=1)
+            if len(solutions) == 0:
+                break
+            all_solutions.extend(solutions)
+            assignment = solutions[0].assignment
+            # constrain the board to not return the same solution again
+            lits = [self.model_vars[p].Not() if assignment[p] == 1 else self.model_vars[p] for p in assignment.keys()]
+            self.model.AddBoolOr(lits)
+            self.model.ClearHints()
+            for k, v in solutions[0].all_other_variables['fc'].items():
+                self.model.AddHint(self.fc[k], v)
+        print(f'Solutions found: {len(all_solutions)}')
+        toc = time.time()
+        print(f'Time taken: {toc - tic:.2f} seconds')
+        return all_solutions