AoC 2023 Day 25 - general solution

Author: pareronia

src/main/python/AoC2023_25.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import random
 import sys
 from collections import defaultdict
 from copy import deepcopy
@@ -33,37 +34,33 @@
 
 
 class Graph(NamedTuple):
-    edges: dict[str, set[str]]
+    edges: dict[str, list[str]]
 
     @classmethod
     def from_input(cls, input: InputData) -> Graph:
-        edges = defaultdict[str, set[str]](set)
+        edges = defaultdict[str, list[str]](list)
         for line in input:
             key, values = line.split(": ")
-            edges[key] |= {_ for _ in values.split()}
+            edges[key] += [_ for _ in values.split()]
             for v in values.split():
-                edges[v].add(key)
+                edges[v].append(key)
         return Graph(edges)
 
-    def remove_edges(self, edges: list[tuple[str, str]]) -> Graph:
-        new_edges = deepcopy(self.edges)
-        for edge in edges:
-            first, second = edge
-            new_edges[first].remove(second)
-            new_edges[second].remove(first)
-        return Graph(new_edges)
+    def combine_nodes(self, node_1: str, node_2: str, new_node: str) -> Graph:
+        self.edges[new_node] = [
+            d for d in self.edges[node_1] if d != node_2
+        ] + [d for d in self.edges[node_2] if d != node_1]
+        for node in {node_1, node_2}:
+            for dst in self.edges[node]:
+                self.edges[dst] = [
+                    new_node if d == node else d for d in self.edges[dst]
+                ]
+            del self.edges[node]
+        return Graph(self.edges)
 
     def get_connected(self, node: str) -> set[str]:
         return flood_fill(node, lambda n: (_ for _ in self.edges[n]))
 
-    def visualize(self, file_name: str) -> None:
-        with open(file_name, "w") as f:
-            print("Graph {", file=f)
-            for k, v in self.edges.items():
-                for vv in v:
-                    print(f"{k} -- {vv}", file=f)
-            print("}", file=f)
-
 
 Input = Graph
 Output1 = int
@@ -74,31 +71,26 @@ class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
         return Graph.from_input(input_data)
 
-    def solve_1(
-        self, graph: Input, disconnects: list[tuple[str, str]]
-    ) -> Output1:
-        g = graph.remove_edges(disconnects)
-        first = g.get_connected(disconnects[0][0])
-        second = g.get_connected(disconnects[0][1])
-        return len(first) * len(second)
-
-    def sample_1(self, graph: Input) -> Output1:
-        return self.solve_1(
-            graph, [("hfx", "pzl"), ("bvb", "cmg"), ("nvd", "jqt")]
-        )
-
     def part_1(self, graph: Input) -> Output1:
-        # visualize with graphviz/neato:
-        # graph.visualize("/mnt/c/temp/graph.dot")
-        # -> to cut: ssd--xqh, nrs--khn, qlc--mqb
-        return self.solve_1(
-            graph, [("ssd", "xqh"), ("nrs", "khn"), ("qlc", "mqb")]
-        )
+        while True:
+            g = deepcopy(graph)
+            counts = {node: 1 for node in g.edges.keys()}
+            while len(g.edges) > 2:
+                a = random.sample(list(g.edges.keys()), 1)[0]
+                b = random.sample(list(g.edges[a]), 1)[0]
+                new_node = f"{a}-{b}"
+                counts[new_node] = counts.get(a, 0) + counts.get(b, 0)
+                del counts[a]
+                del counts[b]
+                g = g.combine_nodes(a, b, new_node)
+            a, b = g.edges.keys()
+            if len(g.edges[a]) == 3:
+                return counts[a] * counts[b]
 
     def part_2(self, input: Input) -> Output2:
         return "🎄"
 
-    @aoc_samples((("sample_1", TEST, 54),))
+    @aoc_samples((("part_1", TEST, 54),))
     def samples(self) -> None:
         pass