Day 25 🎄

Author: WVerlaek

src/main/kotlin/common/datastructures/DisjointSets.kt

@@ -4,10 +4,14 @@ class DisjointSets<T> {
     val rank: MutableMap<T, Int> = mutableMapOf()
     val parent: MutableMap<T, T> = mutableMapOf()
 
+    val size get() = rank.size
+    val sets: MutableSet<T> = mutableSetOf()
+
     private fun checkInit(x: T) {
         if (x in rank) return
         rank[x] = 0
         parent[x] = x
+        sets += x
     }
 
     fun find(x: T): T {
@@ -26,11 +30,14 @@ class DisjointSets<T> {
         }
         if (rank[rootX]!! < rank[rootY]!!) {
             parent[rootX] = rootY
+            sets -= rootX
         } else if (rank[rootY]!! < rank[rootX]!!) {
             parent[rootY] = rootX
+            sets -= rootY
         } else {
             parent[rootY] = rootX
             rank[rootX] = rank[rootX]!! + 1
+            sets -= rootY
         }
     }
 }

src/main/kotlin/common/datastructures/flow/Dinics.kt

@@ -0,0 +1,140 @@
+@file:Suppress("UnstableApiUsage")
+
+package common.datastructures.flow
+
+import com.google.common.graph.ValueGraph
+import java.util.*
+
+object Dinics {
+    fun <T> maxFlow(graph: ValueGraph<T, Int>, src: T, sink: T): Int {
+        return maxFlowGraph(graph, src, sink).first
+    }
+
+    data class MinCut<T>(
+        val srcSet: Set<T>,
+        val cut: List<Pair<T, T>>,
+    )
+
+    fun <T> minCut(graph: ValueGraph<T, Int>, src: T, sink: T): MinCut<T> {
+        val (_, nodes) = maxFlowGraph(graph, src, sink)
+
+        val reachable = mutableSetOf<T>()
+        val queue = LinkedList<Node<T>>().also { it.add(nodes[src]!!) }
+        while (queue.isNotEmpty()) {
+            val cur = queue.removeFirst()
+            if (cur.node in reachable) {
+                continue
+            }
+            reachable += cur.node
+
+            cur.edges.forEach { edge ->
+                if (edge.flow == edge.capacity) {
+                    return@forEach
+                }
+
+                queue += edge.to
+            }
+        }
+
+        val cut = graph.edges().mapNotNull { edge ->
+            val isMinCut = edge.nodeU() in reachable != edge.nodeV() in reachable
+            if (isMinCut) {
+                return@mapNotNull edge.nodeU() to edge.nodeV()
+            }
+            return@mapNotNull null
+        }
+
+        return MinCut(reachable, cut)
+    }
+
+    private fun <T> maxFlowGraph(graph: ValueGraph<T, Int>, src: T, sink: T): Pair<Int, Map<T, Node<T>>> {
+        val nodes = graph.toFlowGraph()
+        val srcNode = nodes[src]!!
+        val sinkNode = nodes[sink]!!
+        var maxFlow = 0
+        while (levelGraph(nodes, srcNode, sinkNode)) {
+            var flow: Int
+            do {
+                flow = sendFlow(srcNode, sinkNode, Int.MAX_VALUE)
+                maxFlow += flow
+            } while (flow > 0)
+        }
+        return maxFlow to nodes
+    }
+
+    class Node<T>(
+        val node: T,
+        var level: Int,
+        var edges: List<Edge<T>>,
+    )
+    data class Edge<T>(
+        val to: Node<T>,
+        val capacity: Int,
+        var flow: Int,
+    ) {
+        lateinit var reverseEdge: Edge<T>
+    }
+
+    private fun <T> sendFlow(from: Node<T>, sink: Node<T>, flow: Int): Int {
+        if (from == sink) {
+            return flow
+        }
+        from.edges.forEach { edge ->
+            if (edge.to.level == from.level + 1 && edge.capacity > edge.flow) {
+                val minFlow = minOf(flow, edge.capacity - edge.flow)
+                val resultFlow = sendFlow(edge.to, sink, minFlow)
+                if (resultFlow > 0) {
+                    edge.flow += resultFlow
+                    edge.reverseEdge.flow -= resultFlow
+                    return resultFlow
+                }
+            }
+        }
+        return 0
+    }
+
+    private fun <T> ValueGraph<T & Any, Int>.toFlowGraph(): Map<T, Node<T>> {
+        val nodes = nodes().toList().associateWith { node ->
+            Node(node, -1, emptyList())
+        }
+
+        fun addEdge(from: Node<T>, to: Node<T>, capacity: Int) {
+            val edge = Edge(to, capacity, 0)
+            val reverse = Edge(from, capacity, capacity)
+            edge.reverseEdge = reverse
+            reverse.reverseEdge = edge
+            from.edges += edge
+            to.edges += reverse
+        }
+
+        edges().forEach { edge ->
+            val from = nodes[edge.nodeU()]!!
+            val to = nodes[edge.nodeV()]!!
+            val value = edgeValue(edge).get()
+            addEdge(from, to, value)
+            if (!edge.isOrdered) {
+                addEdge(to, from, value)
+            }
+        }
+
+        return nodes
+    }
+
+    private fun <T> levelGraph(nodes: Map<T, Node<T>>, src: Node<T>, sink: Node<T>): Boolean {
+        nodes.values.forEach { it.level = -1 }
+        src.level = 0
+
+        val queue = LinkedList<Node<T>>().also { it.add(src) }
+        while (queue.isNotEmpty()) {
+            val cur = queue.removeFirst()
+            for (e in cur.edges) {
+                if (e.flow < e.capacity && e.to.level == -1) {
+                    e.to.level = cur.level + 1
+                    queue += e.to
+                }
+            }
+        }
+
+        return sink.level > 0
+    }
+}

src/main/kotlin/y23/Day25.kt

@@ -0,0 +1,52 @@
+@file:Suppress("UnstableApiUsage")
+
+package y23
+
+import com.google.common.graph.*
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+import common.datastructures.flow.Dinics
+import common.ext.*
+import common.util.*
+import java.util.*
+import kotlin.math.*
+import kotlin.system.exitProcess
+
+
+fun main() = solvePuzzle(year = 2023, day = 25) { Day25(it) }
+
+class Day25(val input: Input) : Puzzle {
+
+    private fun createGraph(lines: List<String>): MutableValueGraph<String, Int> {
+        val graph = ValueGraphBuilder.undirected()
+            .build<String, Int>()
+        lines.forEach { line ->
+            val from = line.substringBefore(":")
+            val to = line.substringAfter(": ").split(" ")
+            to.forEach { graph.putEdgeValue(from, it, 1) }
+        }
+        return graph
+    }
+
+    override fun solveLevel1(): Any {
+        val graph = createGraph(input.lines)
+        val nodes = graph.nodes().toList()
+        for (a in nodes.indices) {
+            for (b in a + 1 until nodes.size) {
+                val maxFlow = Dinics.maxFlow(graph, nodes[a], nodes[b])
+                if (maxFlow == 3) {
+                    val (srcSet, _) = Dinics.minCut(graph, nodes[a], nodes[b])
+                    return srcSet.size * (nodes.size - srcSet.size)
+                }
+            }
+        }
+
+        error("did not find cut of size 3")
+    }
+
+    override fun solveLevel2(): Any {
+        return 42
+    }
+}

src/test/kotlin/y23/Day25Test.kt

@@ -0,0 +1,35 @@
+package y23
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day25Test {
+    private val sample = Input("""
+    jqt: rhn xhk nvd
+    rsh: frs pzl lsr
+    xhk: hfx
+    cmg: qnr nvd lhk bvb
+    rhn: xhk bvb hfx
+    bvb: xhk hfx
+    pzl: lsr hfx nvd
+    qnr: nvd
+    ntq: jqt hfx bvb xhk
+    nvd: lhk
+    lsr: lhk
+    rzs: qnr cmg lsr rsh
+    frs: qnr lhk lsr
+    """.trimIndent())
+
+    private val day = Day25(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(54, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+         assertEquals(42, day.solveLevel2())
+    }
+}