Day 22

answers/22.txt

@@ -0,0 +1,2 @@
+10204
+1004

data/22.txt

@@ -0,0 +1,2 @@
+depth: 7305
+target: 13,734

day22.nim

@@ -0,0 +1,107 @@
+import sequtils, strutils, tables
+
+type
+    Point = tuple[x,y: int]
+    Tool = enum tTorch, tClimbing, tNeither
+    Node = tuple[pos: Point, tool: Tool]
+
+iterator moves(point: Point): Point =
+    let (x, y) = point
+    
+    if y > 0: yield (x, y - 1)
+    if x > 0: yield (x - 1, y)
+    yield (x, y + 1)
+    yield (x + 1, y)
+
+let
+    input = readFile("data/22.txt").splitLines
+    depth = input[0].strip.split(' ')[1].parseInt
+    targetParts = input[1].strip.split(' ')[1].split(',').map(parseInt)
+    target: Point = (targetParts[0], targetParts[1])
+    targetNode: Node = (target, tTorch)
+    tools = [[tClimbing, tTorch], [tClimbing, tNeither], [tTorch, tNeither]]
+
+var
+    erosions = initTable[Point, int]()
+    dangerSum = 0
+
+# Add arbitrary extension to allow for a bit of overshooting.
+for y in 0..target.y + 20:
+    for x in 0..target.x + 20:
+        let
+            geoindex = if (x == 0 and y == 0) or (x, y) == target:
+                    0
+                elif y == 0:
+                    x * 16807
+                elif x == 0:
+                    y * 48271
+                else:
+                    erosions[(x-1, y)] * erosions[(x, y-1)]
+            erosionlevel = (geoindex + depth) mod 20183
+        
+        erosions[(x, y)] = erosionlevel
+        if x <= target.x and y <= target.y:
+            dangerSum += erosionlevel mod 3
+
+# Custom stack of pending steps, kept in order from smallest to largest.
+# Insertion is O(n), removing the smallest is O(1). Performs approximately a
+# billionty times faster than I managed using a Seq/Deque/Table/CountingTable.
+type
+    StackStep = ref object
+        node: Node
+        distance: int
+        next: StackStep
+    
+    Stack = object
+        head: StackStep
+
+proc insert(stack: var Stack, node: Node, distance: int) =
+    var newNode = new(StackStep)
+    newNode.node = node
+    newNode.distance = distance
+
+    if stack.head == nil:
+        stack.head = newNode
+    else:
+        var target = stack.head
+        while target.next != nil and target.next.distance < distance:
+            target = target.next
+        newNode.next = target.next
+        target.next = newNode
+
+proc popSmallest(stack: var Stack): tuple[node: Node, distance: int] =
+    result = (stack.head.node, stack.head.distance)
+    stack.head = stack.head.next
+
+var
+    distances = initTable[Node, int]()
+    stack: Stack
+
+stack.insert(((0, 0), tTorch), 0)
+
+while not distances.hasKey(targetNode):
+    let (node, distance) = stack.popSmallest
+
+    # We can have duplicate steps in our stack, but if we've already
+    # put the distance then that route was necessarily shorter. Just
+    # skip it.
+    if distances.hasKey(node):
+        continue
+    
+    distances[node] = distance
+
+    # At each node we can switch tools once, with a cost of 7 minutes
+    for tool in tools[erosions[node.pos] mod 3]:
+        if tool != node.tool and not distances.hasKey((node.pos, tool)):
+            stack.insert(((node.pos, tool)), distance + 7)
+
+    # Up to four possible moves from the current node, depending on
+    # terrain and tools.
+    for newPos in node.pos.moves:
+        if erosions.hasKey(newPos) and
+                node.tool in tools[erosions[newPos] mod 3] and
+                not distances.hasKey((newPos, node.tool)):
+            stack.insert(((newPos, node.tool)), distance + 1)
+
+echo dangerSum
+echo distances[targetNode]