Solution 2015-09 (All in a Single Night)

rhaendel · rhaendel · commit 92a00749e59f · 2025-07-12T18:30:22.000+02:00
diff --git a/src/main/kotlin/de/ronny_h/aoc/AdventOfCode.kt b/src/main/kotlin/de/ronny_h/aoc/AdventOfCode.kt
@@ -22,7 +22,7 @@ abstract class AdventOfCode<T>(val year: Int, val day: Int) {
             ?: error("The input file for day $day, year $year could not be found. Expected at '$inputFile' in the resources folder.")
     }
 
-    private fun paddedDay(): String = day.toString().padStart(2, '0')
+    fun paddedDay(): String = day.toString().padStart(2, '0')
 
     private fun printAndCheck(input: List<String>, block: (List<String>) -> T, expected: T) {
         printAndCheck(measureTimedValue { block(input) }, expected)
diff --git a/src/main/kotlin/de/ronny_h/aoc/extensions/graphs/TravelingSalesman.kt b/src/main/kotlin/de/ronny_h/aoc/extensions/graphs/TravelingSalesman.kt
@@ -1,11 +1,21 @@
 package de.ronny_h.aoc.extensions.graphs
 
 import java.util.*
+import javax.annotation.processing.Generated
+import kotlin.math.ceil
 
 
 data class TravelingSalesmanProblemSolution(val length: Int, val path: List<Int>)
 
-// TSP implementation inspired from https://www.geeksforgeeks.org/dsa/traveling-salesman-problem-using-branch-and-bound-2/
+// should be larger than any other single weight in the graph
+const val MAX_WEIGHT = 10_000_000
+private const val UNSET = -1
+
+/**
+ * A TSP implementation inspired from https://www.geeksforgeeks.org/dsa/traveling-salesman-problem-using-branch-and-bound-2/
+ *
+ * @param adj An adjacency matrix containing all edge weights.
+ */
 class TravelingSalesman(private val adj: Array<IntArray>) {
     private val N: Int = adj.size
 
@@ -16,7 +26,7 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
     private val visited: BooleanArray = BooleanArray(N)
 
     // Stores the final minimum weight of shortest tour.
-    private var finalLength: Int = Int.Companion.MAX_VALUE
+    private var finalLength: Int = Int.MAX_VALUE
 
     // Function to copy temporary solution to the final solution
     private fun copyToFinal(currentPath: IntArray) {
@@ -28,7 +38,7 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
 
     // Function to find the minimum edge cost having an end at the vertex i
     private fun firstMin(i: Int): Int {
-        var min = Int.MAX_VALUE
+        var min = MAX_WEIGHT
         for (k in 0..<N) {
             if (adj[i][k] < min && i != k) min = adj[i][k]
         }
@@ -37,8 +47,8 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
 
     // function to find the second minimum edge cost having an end at the vertex i
     private fun secondMin(i: Int): Int {
-        var first = Int.MAX_VALUE
-        var second = Int.MAX_VALUE
+        var first = MAX_WEIGHT
+        var second = MAX_WEIGHT
         for (j in 0..<N) {
             if (i == j) continue
 
@@ -52,7 +62,9 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
         return second
     }
 
-    /** function that takes as arguments:
+    /**
+     * Calculates the shortest tour recursively.
+     *
      * @param boundSoFar lower bound of the root node
      * @param weightSoFar stores the weight of the path so far
      * @param level current level while moving in the search space tree
@@ -66,7 +78,7 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
         // means we have covered all the nodes once
         if (level == N) {
             // check if there is an edge from last vertex in path back to the first vertex
-            if (adj[currentPath[level - 1]][currentPath[0]] != 0) {
+            if (adj[currentPath[level - 1]][currentPath[0]] != MAX_WEIGHT) {
                 // currentLength has the total weight of the solution we got
                 val currentLength = currentWeight + adj[currentPath[level - 1]][currentPath[0]]
 
@@ -82,16 +94,16 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
         // for any other level iterate for all vertices to build the search space tree recursively
         for (i in 0..<N) {
             // Consider next vertex if it is not same (diagonal
-            // entry in adjacency matrix and not visited already)
-            if (adj[currentPath[level - 1]][i] != 0 && !visited[i]) {
+            // entry in adjacency matrix) and not visited already
+            if (i != currentPath[level - 1] && !visited[i]) {
                 val temp = currentBound
                 currentWeight += adj[currentPath[level - 1]][i]
 
-                // different computation of curr_bound for level 2 from the other levels
+                // different computation of currentBound for level 2 from the other levels
                 currentBound -= if (level == 1) {
-                    (firstMin(currentPath[0]) + firstMin(i)) / 2
+                    ceil((firstMin(currentPath[0]) + firstMin(i)) / 2.0).toInt()
                 } else {
-                    (secondMin(currentPath[level - 1]) + firstMin(i)) / 2
+                    ceil((secondMin(currentPath[level - 1]) + firstMin(i)) / 2.0).toInt()
                 }
 
                 // currentBound + currentWeight is the actual lower bound for the node that we have arrived on
@@ -105,28 +117,32 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
                 }
 
                 // Else we have to prune the node by resetting
-                // all changes to curr_weight and curr_bound
+                // all changes to currentWeight and currentBound
                 currentWeight -= adj[currentPath[level - 1]][i]
                 currentBound = temp
 
                 // Also reset the visited array
                 Arrays.fill(visited, false)
-                for (j in 0..level - 1) {
-                    visited[currentPath[j]] = true
+                for (j in 0..<level) {
+                    if (currentPath[j] != UNSET) {
+                        visited[currentPath[j]] = true
+                    }
                 }
             }
         }
     }
 
-    // This function sets up final_path[]
-    fun tsp(): TravelingSalesmanProblemSolution {
-        val currentPath = IntArray(N + 1)
+    fun calculateShortestRoundTrip(): TravelingSalesmanProblemSolution {
+        tsp()
+        return TravelingSalesmanProblemSolution(finalLength, finalPath.toList())
+    }
 
+    private fun tsp() {
         // Calculate initial lower bound for the root node
         // using the formula 1/2 * (sum of first min + second min) for all edges.
         // Also initialize the currentPath and visited array
         var currentBound = 0
-        Arrays.fill(currentPath, -1)
+        val currentPath = IntArray(N + 1) { UNSET }
         Arrays.fill(visited, false)
 
         // Compute initial bound
@@ -135,14 +151,80 @@ class TravelingSalesman(private val adj: Array<IntArray>) {
         }
 
         // Rounding off the lower bound to an integer
-        currentBound = if (currentBound == 1) 1 else currentBound / 2
+        currentBound = ceil(currentBound / 2.0).toInt()
 
         // We start at vertex 1 so the first vertex in currentPath[] is 0
         visited[0] = true
         currentPath[0] = 0
 
         tspRecursive(currentBound, 0, 1, currentPath)
+    }
+}
 
-        return TravelingSalesmanProblemSolution(finalLength, finalPath.toList())
+data class Edge<N>(val from: N, val to: N, val weight: Int)
+data class AdjacencyMatrix<N>(val headers: List<N>, val content: Array<IntArray>) {
+    init {
+        require(headers.size == content.size) { "adjacency matrix's headers (${headers.size}) do not match its content (${content.size})" }
+        require(content.all { it.size == headers.size }) { "adjacency matrix is not quadratical" }
+    }
+
+    @Generated
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as AdjacencyMatrix<*>
+
+        if (headers != other.headers) return false
+        if (!content.contentDeepEquals(other.content)) return false
+
+        return true
+    }
+
+    @Generated
+    override fun hashCode(): Int {
+        var result = headers.hashCode()
+        result = 31 * result + content.contentDeepHashCode()
+        return result
+    }
+}
+
+/**
+ * Converts a list of [Edge]s to an adjacency matrix.
+ *
+ * @param symmetrical If `true`, treats all connections in the list of edges symmetrically. That means, an edge from _a_ to _b_ with weight _w_
+ * implies an edge from _b_ to _a_ with weight _w_. Else (the default), only edges that are explicitly in the list are added to the matrix.
+ * @param nullNode If specified (i.e. not `null`), adds a synthetic start node to the matrix with edges of weight `0` to all other nodes.
+ * This way, instead of a complete round-trip, the TSP algorithm calculates a single path containing all nodes - starting with an arbitrary one -
+ * so that the path length is minimized.
+ */
+fun <N> List<Edge<N>>.toAdjacencyMatrix(
+    symmetrical: Boolean = false,
+    nullNode: N? = null
+): Pair<List<Edge<N>>, AdjacencyMatrix<N>> {
+    val originalNodes = flatMap { listOf(it.from, it.to) }.toSet().toList()
+
+    // to solve the start node problem, add a "null node" with distance 0 to all others
+    val nullNodes = nullNode?.let { listOf(it) } ?: emptyList()
+    val nullEdges = nullNode?.let { n -> originalNodes.map { o -> Edge(n, o, 0) } } ?: emptyList()
+
+    val nodes = nullNodes + originalNodes
+    val indices = nodes.mapIndexed { i, node -> node to i }.toMap()
+    val adj = Array(nodes.size) { i ->
+        IntArray(nodes.size) { j -> if (i == j) 0 else MAX_WEIGHT }
+    }
+
+    val allEdges = nullEdges + this
+    allEdges.forEach {
+        val fromIndex = indices.getValue(it.from)
+        val toIndex = indices.getValue(it.to)
+        check(adj[fromIndex][toIndex] == MAX_WEIGHT) { "there is already an edge from node $fromIndex (${it.from}) to $toIndex (${it.to})" }
+        check(it.weight < MAX_WEIGHT) { "this algorithm only works for weights smaller than $MAX_WEIGHT, current: ${it.weight}" }
+        adj[fromIndex][toIndex] = it.weight
+        if (symmetrical) {
+            check(adj[toIndex][fromIndex] == MAX_WEIGHT) { "there is already an edge from node $toIndex (${it.to}) to $fromIndex (${it.from})" }
+            adj[toIndex][fromIndex] = it.weight
+        }
     }
+    return allEdges to AdjacencyMatrix(nodes, adj)
 }
diff --git a/src/main/kotlin/de/ronny_h/aoc/year2015/day09/AllInASingleNight.kt b/src/main/kotlin/de/ronny_h/aoc/year2015/day09/AllInASingleNight.kt
@@ -0,0 +1,67 @@
+package de.ronny_h.aoc.year2015.day09
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.graphs.Edge
+import de.ronny_h.aoc.extensions.graphs.TravelingSalesman
+import de.ronny_h.aoc.extensions.graphs.TravelingSalesmanProblemSolution
+import de.ronny_h.aoc.extensions.graphs.toAdjacencyMatrix
+import java.io.File
+
+fun main() = AllInASingleNight().run(251, 898)
+
+class AllInASingleNight : AdventOfCode<Int>(2015, 9) {
+    override fun part1(input: List<String>) = input.parseEdges().shortestRoundtrip().length
+
+    companion object {
+        fun List<String>.parseEdges() = this.map { line ->
+            val (locations, distance) = line.split(" = ")
+            val (from, to) = locations.split(" to ")
+            Edge(from, to, distance.toInt())
+        }
+    }
+
+    override fun part2(input: List<String>): Int {
+        val distances = input.parseEdges()
+        val maxWeight = distances.maxOf { it.weight } + 1
+        val invertedDistances = distances.map { it.copy(weight = maxWeight - it.weight) }
+        val shortestRoundtrip = invertedDistances.shortestRoundtrip()
+        return (shortestRoundtrip.path.size - 3) * maxWeight - shortestRoundtrip.length
+    }
+
+    private fun List<Edge<String>>.shortestRoundtrip(): TravelingSalesmanProblemSolution {
+        val (edges, adjacencyMatrix) = toAdjacencyMatrix(
+            symmetrical = true,
+            nullNode = "SyntheticStart"
+        )
+        val shortestRoundtrip = TravelingSalesman(adjacencyMatrix.content).calculateShortestRoundTrip()
+        println("nodes: ${adjacencyMatrix.headers}")
+        println("path: ${shortestRoundtrip.path}")
+        // writeToDotFile("part2", edges, adjacencyMatrix.headers, shortestRoundtrip.path)
+        return shortestRoundtrip
+    }
+
+    private fun writeToDotFile(name: String, distances: List<Edge<String>>, headers: List<String>, path: List<Int>) {
+        val indexOf = headers.mapIndexed { i, name -> name to i }.toMap()
+
+        File("${sourcePath()}/$name.dot").printWriter().use { out ->
+            out.println("strict graph {")
+            out.println("  edge [fontname=Arial fontsize=9]")
+            out.println("  node [fontname=Arial]")
+
+            headers.forEachIndexed { i, name ->
+                out.println("  $i [label=\"$i $name\"]")
+            }
+            distances.forEach {
+                val color = if (it.weight == 0) " color=grey48 fontcolor=grey48" else ""
+                out.println("  ${indexOf[it.from]} -- ${indexOf[it.to]} [label=${it.weight}$color]")
+            }
+            path.windowed(2) { (from, to) ->
+                out.println("  $from -- $to [color=red]")
+            }
+
+            out.println("}")
+        }
+    }
+
+    private fun sourcePath(): String = "src/main/kotlin/de/ronny_h/aoc/year$year/day${paddedDay()}"
+}
diff --git a/src/test/kotlin/de/ronny_h/aoc/extensions/graphs/TravelingSalesmanTest.kt b/src/test/kotlin/de/ronny_h/aoc/extensions/graphs/TravelingSalesmanTest.kt
@@ -5,18 +5,75 @@ import io.kotest.matchers.shouldBe
 
 class TravelingSalesmanTest : StringSpec({
 
-    "TSP for a graph with 4 nodes given as adjacency matrix" {
+    "TSP for a complete round-trip on a graph with 4 nodes" {
         val adj: Array<IntArray> = arrayOf(
             intArrayOf(0, 10, 15, 20),
             intArrayOf(10, 0, 35, 25),
             intArrayOf(15, 35, 0, 30),
             intArrayOf(20, 25, 30, 0)
         )
 
-        val shortestPath = TravelingSalesman(adj).tsp()
+        val shortestPath = TravelingSalesman(adj).calculateShortestRoundTrip()
 
         shortestPath.length shouldBe 80
         shortestPath.path shouldBe listOf(0, 1, 3, 2, 0)
     }
 
+    "convert a map of a single distance to an adjacency matrix" {
+        val distances = listOf(Edge("A", "B", 1))
+        val expectedAdjacencyMatrix = arrayOf(
+            intArrayOf(0, 1),
+            intArrayOf(MAX_WEIGHT, 0),
+        )
+        distances.toAdjacencyMatrix() shouldBe (distances to AdjacencyMatrix(listOf("A", "B"), expectedAdjacencyMatrix))
+    }
+
+    "convert a map of multiple distances to an adjacency matrix" {
+        val distances = listOf(Edge("A", "B", 1), Edge("B", "C", 2))
+        val expectedAdjacencyMatrix = arrayOf(
+            intArrayOf(0, 1, MAX_WEIGHT),
+            intArrayOf(MAX_WEIGHT, 0, 2),
+            intArrayOf(MAX_WEIGHT, MAX_WEIGHT, 0),
+        )
+        distances.toAdjacencyMatrix() shouldBe (distances to AdjacencyMatrix(
+            listOf("A", "B", "C"),
+            expectedAdjacencyMatrix
+        ))
+    }
+
+    "convert a map of multiple distances to an adjacency matrix symmetrically" {
+        val distances = listOf(Edge("A", "B", 1), Edge("B", "C", 2))
+        val expectedAdjacencyMatrix = arrayOf(
+            intArrayOf(0, 1, MAX_WEIGHT),
+            intArrayOf(1, 0, 2),
+            intArrayOf(MAX_WEIGHT, 2, 0),
+        )
+        distances.toAdjacencyMatrix(symmetrical = true) shouldBe (distances to AdjacencyMatrix(
+            listOf("A", "B", "C"),
+            expectedAdjacencyMatrix
+        ))
+    }
+
+    "when providing a nullNode, synthetic edges of length 0 are added" {
+        val distances = listOf(Edge("A", "B", 1), Edge("B", "C", 2))
+
+        val syntheticEdges = listOf(
+            Edge("ThisNodeIsArtificial", "A", 0),
+            Edge("ThisNodeIsArtificial", "B", 0),
+            Edge("ThisNodeIsArtificial", "C", 0),
+        )
+        val expectedAdjacencyMatrix = arrayOf(
+            intArrayOf(0, 0, 0, 0),
+            intArrayOf(0, 0, 1, MAX_WEIGHT),
+            intArrayOf(0, 1, 0, 2),
+            intArrayOf(0, MAX_WEIGHT, 2, 0),
+        )
+        distances.toAdjacencyMatrix(
+            symmetrical = true,
+            "ThisNodeIsArtificial"
+        ) shouldBe (syntheticEdges + distances to AdjacencyMatrix(
+            listOf("ThisNodeIsArtificial", "A", "B", "C"),
+            expectedAdjacencyMatrix
+        ))
+    }
 })
diff --git a/src/test/kotlin/de/ronny_h/aoc/year2015/day09/AllInASingleNightTest.kt b/src/test/kotlin/de/ronny_h/aoc/year2015/day09/AllInASingleNightTest.kt

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ abstract class AdventOfCode<T>(val year: Int, val day: Int) {`
`22`	`22`	`?: error("The input file for day $day, year $year could not be found. Expected at '$inputFile' in the resources folder.")`
`23`	`23`	`}`
`24`	`24`
`25`		`- private fun paddedDay(): String = day.toString().padStart(2, '0')`
	`25`	`+ fun paddedDay(): String = day.toString().padStart(2, '0')`
`26`	`26`
`27`	`27`	`private fun printAndCheck(input: List<String>, block: (List<String>) -> T, expected: T) {`
`28`	`28`	`printAndCheck(measureTimedValue { block(input) }, expected)`