Day 20: Race Condition

Author: apostaremczak

2024-java/src/main/java/pl/apostaremczak/aoc/Day20.java

@@ -1,87 +1,65 @@
 package pl.apostaremczak.aoc;
 
+import pl.apostaremczak.aoc.util.CharacterMap2d;
 import pl.apostaremczak.aoc.util.Coord2D;
-import pl.apostaremczak.aoc.util.Map2D;
 
 import java.util.*;
 
 public class Day20 extends PuzzleSolution {
     Coord2D StartPosition;
     Coord2D EndPosition;
-    Map<CheatPosition, Long> CheatedPathLengths = new HashMap<>();
     Long ShortestLegalPath = Long.MAX_VALUE;
-    //    Set<Coord2D> Walls;
-    Map2D<Character> Maze;
+    CharacterMap2d Maze;
     Long SavedTimeThreshold;
-    Set<CheatPosition> ExploredCheats = new HashSet<>();
+    Map<Coord2D, Long> DistancesFromStart;
+    Map<Coord2D, Long> DistancesFromEnd;
+
 
     public Day20(String inputFilename, Long savedTimeThreshold) {
         super(inputFilename);
-        Maze = Map2D.fromStringInputLines(inputLines);
+        Maze = CharacterMap2d.fromStringInputLines(inputLines, '#');
         StartPosition = Maze.findFirst('S').get();
         EndPosition = Maze.findFirst('E').get();
         SavedTimeThreshold = savedTimeThreshold;
-    }
-
-    @Override
-    public Long solvePart1() {
-        findRaceTrackLength(new LinkedList<>(), StartPosition, Optional.empty());
-        // How many cheats would save you at least 100 picoseconds?
-        long result = 0;
-        for (long cheatedPathLength : CheatedPathLengths.values()) {
-            if (ShortestLegalPath - cheatedPathLength >= SavedTimeThreshold) {
-                result++;
-            }
-        }
-        return result;
-    }
 
-    @Override
-    public Long solvePart2() {
-        return 0L;
+        DistancesFromStart = Maze.getDistancesFrom(StartPosition);
+        DistancesFromEnd = Maze.getDistancesFrom(EndPosition);
+        ShortestLegalPath = DistancesFromStart.get(EndPosition);
     }
 
-    private Boolean isWall(Coord2D position) {
-        return Maze.safeGetAt(position).orElse('X').equals('#');
-    }
-
-    // DFS for finding track lengths
-    private void findRaceTrackLength(LinkedList<Coord2D> visited, Coord2D currentNode, Optional<CheatPosition> cheatPosition) {
-        visited.add(currentNode);
-
-        if (currentNode.equals(EndPosition)) {
-            long currentPathLength = visited.size();
-            if (cheatPosition.isEmpty()) {
-                if (currentPathLength < ShortestLegalPath) {
-                    ShortestLegalPath = currentPathLength;
-                }
-            } else {
-                CheatedPathLengths.put(cheatPosition.get(), currentPathLength);
-            }
-        }
+    private Long countShortcuts(Integer maxShortcutLength) {
+        long shorterPathCount = 0L;
 
-        for (Coord2D neighbor : currentNode.getStraightSurrounding()) {
-            if (!visited.contains(neighbor) && Maze.isWithinBounds(neighbor)) {
-                // Try cheating if it hasn't been done already and if the next tile after the wall is not a wall itself
-                if (isWall(neighbor) && cheatPosition.isEmpty()) {
-                    Coord2D direction = neighbor.minus(currentNode);
-                    Coord2D afterWallNode = neighbor.add(direction);
-                    if (Maze.isWithinBounds(afterWallNode) && !isWall(afterWallNode) && !visited.contains(afterWallNode)) {
-                        LinkedList<Coord2D> cheatVisited = new LinkedList<>(visited);
-                        cheatVisited.add(neighbor);
-                        CheatPosition cheat = new CheatPosition(neighbor, afterWallNode);
-                        if (!ExploredCheats.contains(cheat)) {
-                            ExploredCheats.add(cheat);
-                            findRaceTrackLength(cheatVisited, afterWallNode, Optional.of(cheat));
+        // Iterate over all non-wall points on the grid
+        for (int rowIdx = 0; rowIdx <= Maze.MAX_ROW_INDEX; rowIdx++) {
+            for (int colIdx = 0; colIdx <= Maze.MAX_COLUMN_INDEX; colIdx++) {
+                Coord2D currentPosition = new Coord2D(rowIdx, colIdx);
+                if (!Maze.isWall(currentPosition)) {
+                    // Check all the neighbors and check if the tile after the neighbor is free
+                    for (Coord2D teleport : Maze.getManhattanClosedBallPoints(currentPosition, maxShortcutLength)) {
+                        if (!Maze.isWall(teleport)) {
+                            // Teleporting from p to q through a cheat
+                            // d(S, p) + d(p, q) + d(q, E)
+                            long cheatedDistance = DistancesFromStart.get(currentPosition) + currentPosition.manhattanDistanceFrom(teleport) + DistancesFromEnd.get(teleport);
+                            if (ShortestLegalPath - cheatedDistance >= SavedTimeThreshold) {
+                                shorterPathCount++;
+                            }
                         }
                     }
                 }
-                // Turn and proceed normally
-                if (!isWall(neighbor)) {
-                    findRaceTrackLength(new LinkedList<>(visited), neighbor, cheatPosition);
-                }
             }
         }
+        return shorterPathCount;
+    }
+
+    @Override
+    public Long solvePart1() {
+        return countShortcuts(2);
+    }
+
+    @Override
+    public Long solvePart2() {
+        return countShortcuts(20);
     }
 
     public static void main(String[] args) {
@@ -93,7 +71,3 @@ public static void main(String[] args) {
     }
 }
 
-record CheatPosition(Coord2D first, Coord2D second) {
-
-}
-

2024-java/src/main/java/pl/apostaremczak/aoc/util/CharacterMap2d.java

@@ -0,0 +1,49 @@
+package pl.apostaremczak.aoc.util;
+
+import java.util.*;
+
+public class CharacterMap2d extends Map2D<Character> {
+    Character WallSymbol;
+
+    public CharacterMap2d(Character[][] lines, Character wallSymbol) {
+        super(lines);
+        WallSymbol = wallSymbol;
+    }
+
+    public static CharacterMap2d fromStringInputLines(String[] inputLines, Character wallSymbol) {
+        return new CharacterMap2d(Arrays.stream(inputLines)
+                .map(line -> line.chars().mapToObj(c -> (char) c).toArray(Character[]::new))
+                .toArray(Character[][]::new), wallSymbol);
+    }
+
+    public Boolean isWall(Coord2D position) {
+        return this.safeGetAt(position).orElse('£').equals(WallSymbol);
+    }
+
+    /**
+     * BFS to find maze distances between a start point and all the other points.
+     *
+     * @param startPoint From where should the distances be calculated?
+     * @return Map: { point -> distance from start to that point }
+     */
+    public Map<Coord2D, Long> getDistancesFrom(Coord2D startPoint) {
+        ArrayDeque<Coord2D> queue = new ArrayDeque<>();
+        Map<Coord2D, Long> distancesFromStart = new HashMap<>();
+
+        queue.offer(startPoint);
+        distancesFromStart.put(startPoint, 0L);
+
+        while (!queue.isEmpty()) {
+            Coord2D current = queue.remove();
+            Long currentDistance = distancesFromStart.get(current);
+            for (Coord2D neighbor : current.getStraightSurrounding()) {
+                // Hasn't been visited yet, is still on the map and isn't a wall
+                if (!distancesFromStart.containsKey(neighbor) && isWithinBounds(neighbor) && !safeGetAt(neighbor).orElse('_').equals(WallSymbol)) {
+                    distancesFromStart.put(neighbor, currentDistance + 1);
+                    queue.offer(neighbor);
+                }
+            }
+        }
+        return distancesFromStart;
+    }
+}

2024-java/src/main/java/pl/apostaremczak/aoc/util/Coord2D.java

@@ -60,7 +60,11 @@ public Coord2D rotateRightAngle(double angle) {
         return new Coord2D((int) newX, (int) newY);
     }
 
-    public Double euclideanDistance(Coord2D other) {
+    public Double euclideanDistanceFrom(Coord2D other) {
         return Math.sqrt(Math.pow(this.row - other.row, 2) + Math.pow(this.column - other.column, 2));
     }
+
+    public Integer manhattanDistanceFrom(Coord2D other) {
+        return Math.abs(this.row - other.row) + Math.abs(this.column - other.column);
+    }
 }

2024-java/src/main/java/pl/apostaremczak/aoc/util/Map2D.java

@@ -1,7 +1,6 @@
 package pl.apostaremczak.aoc.util;
 
-import java.util.Arrays;
-import java.util.Optional;
+import java.util.*;
 
 public class Map2D<T> {
     public final T[][] internal;
@@ -26,17 +25,97 @@ public Optional<T> safeGetAt(Coord2D coord) {
     }
 
     public T getAt(Coord2D coord) {
-        assert isWithinBounds(coord): "Requested a field of out the map's boundaries";
+        assert isWithinBounds(coord) : "Requested a field of out the map's boundaries";
         return internal[coord.row()][coord.column()];
     }
 
     public boolean isWithinBounds(Coord2D coord) {
         return coord.row() >= 0 && coord.row() <= MAX_ROW_INDEX && coord.column() >= 0 && coord.column() <= MAX_COLUMN_INDEX;
     }
 
+    public Optional<Coord2D> findFirst(T element) {
+        for (int rowIdx = 0; rowIdx <= MAX_ROW_INDEX; rowIdx++) {
+            for (int colIdx = 0; colIdx <= MAX_COLUMN_INDEX; colIdx++) {
+                Coord2D currentPosition = new Coord2D(rowIdx, colIdx);
+                if (getAt(currentPosition).equals(element)) {
+                    return Optional.of(currentPosition);
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
+    public Set<Coord2D> findAll(T element) {
+        Set<Coord2D> occurrences = new HashSet<>();
+        for (int rowIdx = 0; rowIdx <= MAX_ROW_INDEX; rowIdx++) {
+            for (int colIdx = 0; colIdx <= MAX_COLUMN_INDEX; colIdx++) {
+                Coord2D currentPosition = new Coord2D(rowIdx, colIdx);
+                if (getAt(currentPosition).equals(element)) {
+                    occurrences.add(currentPosition);
+                }
+            }
+        }
+        return occurrences;
+    }
+
     public static Map2D<Character> fromStringInputLines(String[] inputLines) {
         return new Map2D<>(Arrays.stream(inputLines)
                 .map(line -> line.chars().mapToObj(c -> (char) c).toArray(Character[]::new))
                 .toArray(Character[][]::new));
     }
+
+    public Iterator<Coord2D> positionIterator() {
+        return new Iterator<Coord2D>() {
+            private int currentRow = 0;
+            private int currentCol = 0;
+
+            @Override
+            public boolean hasNext() {
+                return currentRow <= MAX_ROW_INDEX && currentCol <= MAX_COLUMN_INDEX;
+            }
+
+            @Override
+            public Coord2D next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                Coord2D current = new Coord2D(currentRow, currentCol);
+                if (currentCol < MAX_COLUMN_INDEX) {
+                    currentCol++;
+                } else {
+                    currentCol = 0;
+                    currentRow++;
+                }
+                return current;
+            }
+        };
+    }
+
+    /**
+     * All points in the grid that are at == radius distance from the center, calculated with the Manhattan metric.
+     */
+    public Set<Coord2D> getManhattanDiscPoints(Coord2D center, Integer radius) {
+        Set<Coord2D> discElements = new HashSet<>();
+        for (Iterator<Coord2D> it = this.positionIterator(); it.hasNext(); ) {
+            Coord2D gridPoint = it.next();
+            if (!gridPoint.equals(center) && center.manhattanDistanceFrom(gridPoint).equals(radius)) {
+                discElements.add(gridPoint);
+            }
+        }
+        return discElements;
+    }
+
+    /**
+     * All points in the grid that are at <= radius distance from the center, calculated with the Manhattan metric.
+     */
+    public Set<Coord2D> getManhattanClosedBallPoints(Coord2D center, Integer radius) {
+        Set<Coord2D> discElements = new HashSet<>();
+        for (Iterator<Coord2D> it = this.positionIterator(); it.hasNext(); ) {
+            Coord2D gridPoint = it.next();
+            if (!gridPoint.equals(center) && center.manhattanDistanceFrom(gridPoint) <= radius) {
+                discElements.add(gridPoint);
+            }
+        }
+        return discElements;
+    }
 }

2024-java/src/test/java/pl/apostaremczak/aoc/Day20Tests.java

@@ -15,7 +15,9 @@ public void testSolvePart1() {
 
     @Test
     public void testSolvePart2() {
-        Long result = day20.solvePart2();
-        assertEquals(0L, result);
+        final Day20 day = new Day20("src/test/resources/20.txt", 50L);
+
+        Long result = day.solvePart2();
+        assertEquals(285L, result);
     }
 }