Play around with some graph algos

MeanderingProgrammer · MeanderingProgrammer · commit 31ad1fa2c1df · 2024-04-12T22:18:39.000-07:00
diff --git a/2015/22/solver.py b/2015/22/solver.py
@@ -1,7 +1,8 @@
+import heapq
 from dataclasses import dataclass
 from typing import Optional, Self
 
-from aoc import answer, search
+from aoc import answer
 from aoc.parser import Parser
 
 
@@ -11,6 +12,9 @@ class Stats:
     attack: int = 0
     armor: int = 0
 
+    def dead(self) -> bool:
+        return self.hp <= 0
+
     def add(self, other: Self) -> Self:
         return type(self)(
             hp=self.hp + other.hp,
@@ -81,7 +85,7 @@ class Game:
     spells: frozenset[Spell]
 
     def get_moves(self) -> list[tuple[int, Self]]:
-        if self.player.hp <= 0:
+        if self.player.dead():
             return []
         return [
             (spell.effect().cost, self.move(spell))
@@ -144,11 +148,23 @@ def play_game(hp: int, attack: int, damage: int) -> Optional[int]:
         damage=Stats(hp=damage),
         spells=frozenset(),
     )
-    return search.bfs_complete(
-        (0, game),
-        lambda current: current.enemy.hp <= 0,
-        lambda current: current.get_moves(),
-    )
+    return dijkstra(game)
+
+
+def dijkstra(start: Game) -> Optional[int]:
+    queue: list[tuple[int, Game]] = [(0, start)]
+    seen: set[Game] = set()
+    while len(queue) > 0:
+        mana_used, game = heapq.heappop(queue)
+        if game in seen:
+            continue
+        seen.add(game)
+        if game.enemy.dead():
+            return mana_used
+        for cost, next_game in game.get_moves():
+            if next_game not in seen:
+                heapq.heappush(queue, (mana_used + cost, next_game))
+    return None
 
 
 if __name__ == "__main__":
diff --git a/2016/02/solver.py b/2016/02/solver.py
@@ -1,55 +1,58 @@
 from aoc import answer
 from aoc.grid import Grid
 from aoc.parser import Parser
-from aoc.point import Direction, Point, PointHelper
+from aoc.point import Point
+
+DIRECTIONS: dict[str, Point] = dict(
+    U=(0, -1),
+    D=(0, 1),
+    L=(-1, 0),
+    R=(1, 0),
+)
 
 
 @answer.timer
 def main() -> None:
-    answer.part1("47978", get_code([[7, 8, 9], [4, 5, 6], [1, 2, 3]]))
-    answer.part2(
-        "659AD",
-        get_code(
-            [
-                ["*", "*", "D", "*", "*"],
-                ["*", "A", "B", "C", "*"],
-                [5, 6, 7, 8, 9],
-                ["*", 2, 3, 4, "*"],
-                ["*", "*", 1, "*", "*"],
-            ]
-        ),
-    )
-
-
-def get_code(pattern: list[list[int | str]]) -> str:
-    phone, position = create_phone(pattern)
-    code = ""
-    for instruction in Parser().lines():
-        position = follow(phone, position, instruction)
-        code += str(phone[position])
-    return code
-
-
-def create_phone(pattern: list[list[int | str]]) -> tuple[Grid, Point]:
-    phone = dict()
-    start = None
+    instructions: list[str] = Parser().lines()
+    keypad_1: list[list[str]] = [
+        ["1", "2", "3"],
+        ["4", "5", "6"],
+        ["7", "8", "9"],
+    ]
+    answer.part1("47978", get_code(instructions, keypad_1))
+    keypad_2: list[list[str]] = [
+        ["*", "*", "1", "*", "*"],
+        ["*", "2", "3", "4", "*"],
+        ["5", "6", "7", "8", "9"],
+        ["*", "A", "B", "C", "*"],
+        ["*", "*", "D", "*", "*"],
+    ]
+    answer.part2("659AD", get_code(instructions, keypad_2))
+
+
+def get_code(instructions: list[str], keypad: list[list[str]]) -> str:
+    phone: Grid[str] = create_phone(keypad)
+    position: Point = {digit: location for location, digit in phone.items()}["5"]
+
+    code: list[str] = []
+    for instruction in instructions:
+        for direction in instruction:
+            dx, dy = DIRECTIONS[direction]
+            new_position: Point = (position[0] + dx, position[1] + dy)
+            if new_position in phone:
+                position = new_position
+        code.append(phone[position])
+    return "".join(code)
+
+
+def create_phone(pattern: list[list[str]]) -> Grid[str]:
+    phone: Grid[str] = dict()
     for y, row in enumerate(pattern):
         for x, value in enumerate(row):
-            point = (x, y)
+            point: Point = (x, y)
             if value != "*":
                 phone[point] = value
-            if value == 5:
-                start = point
-    assert start is not None
-    return phone, start
-
-
-def follow(phone: Grid, position: Point, instruction: str) -> Point:
-    for direction in instruction:
-        new_position = PointHelper.go(position, Direction.from_str(direction))
-        if new_position in phone:
-            position = new_position
-    return position
+    return phone
 
 
 if __name__ == "__main__":
diff --git a/2016/13/solver.py b/2016/13/solver.py
@@ -8,21 +8,20 @@
 
 @dataclass(frozen=True)
 class Maze:
-    grid: Grid
+    grid: Grid[bool]
     favorite_number: int
 
     def get_adjacent(self, point: Point) -> list[Point]:
-        result = set()
+        result: set[Point] = set()
         for adjacent in PointHelper.neighbors(point):
             if adjacent[0] >= 0 and adjacent[1] >= 0:
                 if adjacent not in self.grid:
-                    self.grid[adjacent] = self.is_wall(adjacent)
+                    self.grid[adjacent] = self.is_wall(*adjacent)
                 if not self.grid[adjacent]:
                     result.add(adjacent)
         return list(result)
 
-    def is_wall(self, point: Point) -> bool:
-        x, y = point
+    def is_wall(self, x: int, y: int) -> bool:
         value = (x * x) + (3 * x) + (2 * x * y) + y + y * y
         value += self.favorite_number
         value = bin(value)[2:]
@@ -33,9 +32,23 @@ def is_wall(self, point: Point) -> bool:
 @answer.timer
 def main() -> None:
     maze = Maze(grid=dict(), favorite_number=Parser().integer())
-    start, goal = (1, 1), (31, 39)
-    answer.part1(92, search.bfs(start, goal, maze.get_adjacent))
-    answer.part2(124, len(search.reachable(start, 50, maze.get_adjacent)))
+    start: Point = (1, 1)
+    answer.part1(92, search.bfs(start, (31, 39), maze.get_adjacent))
+    answer.part2(124, len(reachable(start, 50, maze)))
+
+
+def reachable(start: Point, maximum: int, maze: Maze) -> set[Point]:
+    queue: list[tuple[int, Point]] = [(0, start)]
+    seen: set[Point] = set()
+    while len(queue) > 0:
+        length, position = queue.pop(0)
+        if position in seen:
+            continue
+        seen.add(position)
+        for adjacent in maze.get_adjacent(position):
+            if adjacent not in seen and length < maximum:
+                queue.append((length + 1, adjacent))
+    return seen
 
 
 if __name__ == "__main__":
diff --git a/2016/17/solver.py b/2016/17/solver.py
@@ -1,46 +1,50 @@
 import hashlib
 
-from aoc import answer, search
+from aoc import answer
 from aoc.parser import Parser
-from aoc.point import Direction, Point, PointHelper
+from aoc.point import Point
 
-DIRECTIONS: list[str] = ["U", "D", "L", "R"]
+DIRECTIONS: list[tuple[str, Point]] = [
+    ("U", (0, 1)),
+    ("D", (0, -1)),
+    ("L", (-1, 0)),
+    ("R", (1, 0)),
+]
+
+LEGAL_HASH: list[str] = ["b", "c", "d", "e", "f"]
 
 
 @answer.timer
 def main() -> None:
-    code = Parser().string()
-    paths = search.bfs_paths(((-3, 3), code), (0, 0), get_adjacent)
-    answer.part1("DDRLRRUDDR", pull_path(code, paths[0]))
-    answer.part2(556, len(pull_path(code, paths[-1])))
-
-
-def get_adjacent(item: tuple[Point, str]) -> list[tuple[Point, str]]:
-    point, code = item
-    hashed = hash(code)
+    code: str = Parser().string()
+    paths: list[str] = bfs(code, (-3, 3), (0, 0))
+    answer.part1("DDRLRRUDDR", paths[0])
+    answer.part2(556, len(paths[-1]))
+
+
+def bfs(code: str, start: Point, end: Point) -> list[str]:
+    queue: list[tuple[Point, str]] = [(start, "")]
+    paths: list[str] = []
+    while len(queue) > 0:
+        point, path = queue.pop(0)
+        if point == end:
+            paths.append(path)
+        else:
+            for adjacent in get_adjacent(code, point, path):
+                queue.append(adjacent)
+    return paths
+
+
+def get_adjacent(code: str, point: Point, path: str) -> list[tuple[Point, str]]:
+    hashed: str = hashlib.md5(str.encode(code + path)).hexdigest()
     result: list[tuple[Point, str]] = []
-    for i, name in enumerate(DIRECTIONS):
-        next_point = PointHelper.go(point, Direction.from_str(name))
-        if is_legal(next_point) and unlocked(hashed[i]):
-            result.append((next_point, code + name))
+    for i, (symbol, direction) in enumerate(DIRECTIONS):
+        x, y = (point[0] + direction[0], point[1] + direction[1])
+        in_bounds: bool = x >= -3 and x <= 0 and y <= 3 and y >= 0
+        if in_bounds and hashed[i] in LEGAL_HASH:
+            result.append(((x, y), path + symbol))
     return result
 
 
-def is_legal(p: Point) -> bool:
-    return p[0] >= -3 and p[0] <= 0 and p[1] <= 3 and p[1] >= 0
-
-
-def unlocked(value: str) -> bool:
-    return value in ["b", "c", "d", "e", "f"]
-
-
-def hash(value: str) -> str:
-    return hashlib.md5(str.encode(value)).hexdigest()[:4]
-
-
-def pull_path(code: str, value: str) -> str:
-    return value[len(code) :]
-
-
 if __name__ == "__main__":
     main()
diff --git a/2017/12/solver.py b/2017/12/solver.py
@@ -1,40 +1,58 @@
 from collections import defaultdict
+from dataclasses import dataclass
 from typing import Optional
 
-from aoc import answer, search
+from aoc import answer
 from aoc.parser import Parser
 
 
+@dataclass(frozen=True)
+class Graph:
+    graph: dict[str, set[str]]
+
+    def connected(self, start: str) -> set[str]:
+        queue: list[str] = [start]
+        seen: set[str] = set()
+        while len(queue) > 0:
+            current = queue.pop()
+            if current in seen:
+                continue
+            seen.add(current)
+            for adjacent in self.graph[current]:
+                if adjacent not in seen:
+                    queue.append(adjacent)
+        return seen
+
+    def get_ungrouped(self, grouped: set[str]) -> Optional[str]:
+        all_keys: set[str] = set(self.graph.keys())
+        remainder: set[str] = all_keys - grouped
+        return None if len(remainder) == 0 else next(iter(remainder))
+
+
 @answer.timer
 def main() -> None:
     graph = get_graph()
-    connected_to_0 = search.connected(graph, "0")
+
+    connected_to_0: set[str] = graph.connected("0")
     answer.part1(306, len(connected_to_0))
 
     heads: set[str] = set(["0"])
-    grouped = connected_to_0
-    head = get_ungrouped(graph, grouped)
+    grouped: set[str] = connected_to_0
+    head: Optional[str] = graph.get_ungrouped(grouped)
     while head is not None:
         heads.add(head)
-        connected = search.connected(graph, head)
-        grouped |= connected
-        head = get_ungrouped(graph, grouped)
+        grouped |= graph.connected(head)
+        head = graph.get_ungrouped(grouped)
     answer.part2(200, len(heads))
 
 
-def get_graph() -> dict[str, set[str]]:
+def get_graph() -> Graph:
     graph: dict[str, set[str]] = defaultdict(set)
     for line in Parser().lines():
         start, ends = line.split(" <-> ")
         for end in ends.split(", "):
             graph[start].add(end)
-    return graph
-
-
-def get_ungrouped(graph: dict[str, set[str]], grouped: set[str]) -> Optional[str]:
-    all_keys = set(graph.keys())
-    remainder = all_keys - grouped
-    return None if len(remainder) == 0 else next(iter(remainder))
+    return Graph(graph=graph)
 
 
 if __name__ == "__main__":
diff --git a/2019/15/solver.py b/2019/15/solver.py
diff --git a/commons/python/aoc/search.py b/commons/python/aoc/search.py
