This is the part of AoC when I start to fall behind. =P

Day 16 took me several days to do, when I could find time to work on it. I did actually intuit

what the best solution for part 1 probably was, but I was lazy and wasted time banging out a

naive solution, hoping it would be good enough. It wasn't; it worked for the sample data, but it

would run out of memory on the real input. So in the long run, it cost me more time than if I

went with the right solution from the start.

The biggest stumbling block was adapting the well-known algorithm (I won't give it away here,

it's in the code) to handle the direction of the reindeer in the maze, and accounting for that

in the cost of the weighted edges of the graph.

package com.codefork.aoc2024.day14;

import com.codefork.aoc2024.Problem;

import com.codefork.aoc2024.util.Assert;

import java.util.Map;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.Scanner;

public class Part02 extends Problem {

public String solve(int width, int height, Stream<String> data) {

var swarm = Swarm.create(data, width, height);

var keepGoing = true;

var i = 0;

var scanner = new Scanner(System.in);

while(i < 1000000) {

var newSwarm = swarm.doMoves(1);

// an xmas tree is going to be bottom heavy, so only show the trees

// where bottom sections have more robots than top ones

var quadrantCounts = newSwarm.getQuadrantCounts();

var bottomHeavy = quadrantCounts.get(2).floatValue() > quadrantCounts.get(0).floatValue() * 1.25 &&

quadrantCounts.get(3).floatValue() > quadrantCounts.get(1).floatValue() * 1.25;

// var topHeavy = quadrantCounts.get(0).floatValue() > quadrantCounts.get(2).floatValue() * 1.4 &&

// quadrantCounts.get(1).floatValue() > quadrantCounts.get(3).floatValue() * 1.4;

if (bottomHeavy) {

System.out.println("--------------------------");

System.out.println("i=" + i);

newSwarm.print();

}

// -------------------------------------------------------------

// var sectionCounts = newSwarm.getCustomSectionCounts();

// if (sectionCounts.get(4) > sectionCounts.get(2) &&

// sectionCounts.get(2) > sectionCounts.get(0) &&

// sectionCounts.get(5) > sectionCounts.get(3) &&

// sectionCounts.get(3) > sectionCounts.get(1)) {

// System.out.println("--------------------------");

// System.out.println("i=" + i);

// newSwarm.print();

// }

// --------------------------------------------------

// record Pos(int x, int y) {

// }

//

// var counts = newSwarm.robots().stream()

// .collect(Collectors.toMap(

// robot -> new Pos(robot.x(), robot.y()),

// robot -> 1,

// Integer::sum));

//

// if(counts.values().stream().anyMatch(c -> c > 5)) {

// System.out.println("--------------------------");

// System.out.println("i=" + i);

// newSwarm.print();

// }

//scanner.nextLine();

swarm = newSwarm;

i++;

}

return String.valueOf(i);

}

@Override

public String solve() {

return solve(101, 103, getInput());

}

public static void main(String[] args) {

new Part02().run();

}

}

package com.codefork.aoc2024.day16;

import com.codefork.aoc2024.util.Assert;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

public record Dijkstra(Maze maze, Map<Reindeer, Integer> dist, Map<Reindeer, Set<Reindeer>> prev) {

private static int INFINITY = Integer.MAX_VALUE;

public static Dijkstra create(Maze maze, Set<Edge> edges) {

// intermediate record

record ReindeerDist(Reindeer r, int d) {

}

// all the reindeer found in "from" part of edges

var allReindeer = edges.stream()

.map(Edge::from)

.collect(Collectors.toSet());

// distances of all reindeer from start

Map<Reindeer, Integer> dist = new HashMap<>();

for (Reindeer r : allReindeer) {

dist.put(r, INFINITY);

}

dist.put(new Reindeer(maze.start(), Direction.East), 0);

// The prev array contains pointers to previous-hop nodes on

// the shortest path from source to the given vertex

Map<Reindeer, Set<Reindeer>> prev = new HashMap<>();

List<Reindeer> q = new ArrayList<>(allReindeer);

while (!q.isEmpty()) {

// find a position that has minimum value in dist

var u = q.stream()

.map(r -> new ReindeerDist(r, dist.get(r)))

.min(Comparator.comparingInt(ReindeerDist::d))

.orElseThrow()

.r();

q.remove(u);

//System.out.println("doing " + u);

var edgesFromU = edges.stream()

.filter(e -> e.from().equals(u))

.toList();

// each neighbor of u that's still in Q

var neighbors = edgesFromU.stream()

.map(Edge::to)

.filter(q::contains)

.toList();

//System.out.println("neighbors for " + u + " = " + neighbors);

for (var v : neighbors) {

var joiningEdges = edgesFromU.stream()

.filter(e -> e.to().equals(v))

.toList();

Assert.assertEquals(1, joiningEdges.size());

var joiningEdge = joiningEdges.getFirst();

// sanity check

var alt = dist.get(u) + joiningEdge.score();

// modification of original algorithm: instead of checking if alt < dist[v],

// we check if it's <= to build all shortest paths, not just one. accordingly,

// prev is a Map<Reindeer, Set<Reindeer>> instead of a Map<Reindeer, Reindeer>

if (alt <= dist.get(v)) {

dist.put(v, alt);

//prev.put(v, u);

if(!prev.containsKey(v)) {

prev.put(v, new HashSet<>());

}

prev.get(v).add(u);

}

}

}

return new Dijkstra(maze, dist, prev);

}

/**

public List<List<Reindeer>> findBestPaths() {

// there can be different ways to reach the end (approaching from diff directions)

var reindeerEnds = maze

.getPossibleApproaches(maze.end())

.stream()

.map(d -> new Reindeer(maze.end(), d))

.toList();

record PathAndScore(List<Reindeer> path, int score) {

}

// find all the paths for different Reindeer ends

var pathsAndScores = reindeerEnds.stream()

.flatMap(u -> {

// construct a path by working backwards from maze end

List<Reindeer> path = new LinkedList<>();

if (prev.containsKey(u) || u.pos().equals(maze.start())) {

while (u != null) {

path.addFirst(u);

if(prev.containsKey(u)) {

// arbitarily pick the first item, doesn't matter

// since we just want any shortest path

u = prev.get(u).stream().findFirst().orElseThrow();

} else {

u = null;

}

}

}

if (!path.isEmpty()) {

return Stream.of(new PathAndScore(path, Reindeer.getPathScore(path)));

}

return Stream.empty();

}).toList();

// find the lowest score, and just return the path(s) with that score

var minScore = pathsAndScores.stream()

.min(Comparator.comparingInt(PathAndScore::score))

.orElseThrow()

.score();

return pathsAndScores.stream()

.filter(pas -> pas.score() == minScore)

.map(PathAndScore::path)

.toList();

}

/**

public int countTilesOnEveryShortestPathToEnd(Reindeer reindeerEnd) {

record Pair(Reindeer start, Reindeer end) {

}

// walk back from end to the start of the maze,

// grouping reindeer into pairs so we can calculate

// the tile positions we've walked

var visited = new HashSet<Reindeer>();

var tiles = new HashSet<Position>();

var toProcess = new LinkedList<Pair>();

toProcess.add(new Pair(reindeerEnd, reindeerEnd));

while (!toProcess.isEmpty()) {

var pair = toProcess.removeFirst();

var prevReindeer = pair.end();

tiles.addAll(pair.start().tiles(prevReindeer));

// if we've seen this Reindeer already, we don't need to walk it further

if(visited.contains(prevReindeer)) {

continue;

}

if(prev.containsKey(prevReindeer)) {

// create new Pairs for ALL the previous reindeer, to the queue.

// this ensures this walk reaches the tiles on any shortest path.

for (var prevItem : prev.get(prevReindeer)) {

toProcess.add(new Pair(prevReindeer, prevItem));

}

}

visited.add(prevReindeer);

}

return tiles.size();

}

}

package com.codefork.aoc2024.day16;

public enum Direction {

North, East, South, West

}

package com.codefork.aoc2024.day16;

import java.util.List;

import java.util.stream.IntStream;

import static com.codefork.aoc2024.util.FoldLeft.foldLeft;

public record Edge(Reindeer from, Reindeer to) {

public static int calculateScore(List<Edge> path) {

return IntStream.range(0, path.size()).boxed().collect(foldLeft(

() -> 0,

(acc, i) -> acc + path.get(i).score()

));

}

@Override

public String toString() {

return String.format("%s,%s %s -> %s,%s %s (score: %s)",

from.pos().x(),

from.pos().y(),

from.dir(),

to.pos().x(),

to.pos().y(),

to.dir(),

score());

}

public int score() {

return from.score(to);

}

}