const day23a = @import("day23a.zig");
const day23b = @import("day23b.zig");
const day24a = @import("day24a.zig");
const day24b = @import("day24b.zig");
const day25a = @import("day25a.zig");

    _ = try day23a.first();
    _ = try day23b.second();
    _ = try day24a.first();
    _ = try day24b.second();
    _ = try day25a.first();

    std.debug.print("Day 24b result: {d} \t\ttime: {d}µs\n", .{ ret, t });

    std.debug.print("Day 24b result: {d} \ttime: {d}µs\n", .{ ret, t });

    std.debug.print("Day 24a result: {d} \t\ttime: {d}µs\n", .{ ret, t });

    std.debug.print("Day 24a result: {d} \ttime: {d}µs\n", .{ ret, t });

const days = 22;

const days = 25;

            if (day == 25 and part == 'b') continue; // There is no 25b

 - [Another one in Rust](https://programsareproofs.com/articles/aoc_2021.html)

Zig version 0.9.0 with `-Drelease-fast` build option.

Zig version 0.9.1 with `-Drelease-fast` build option.

TODO: Day23 fails when built with `-Drelease-fast`, so using `-Drelease-safe` for
now.

TODO: There is a zig compiler error when I try to simplify the if statement.
This needs further investigation.

### First solution

## Day 23
I use Dijksra to solve this one. The various state representation is the
following:
```zig
const Amphipod = enum { A, B, C, D, };
const hallway_length = 7;
const siderooms = 4;
const sideroom_depth = 2; // 4 int the second part
const State = struct {
    hallway: [hallway_length]?Amphipod,
    rooms: [siderooms][sideroom_depth]?Amphipod,
};
```
I do not think that I am doing any particularly smart with the moves. But I move
the Amphipod to it's room whenever that is possible to lower state count.
I store state and it's energy in a `std.PriorityQueue`. I do not update queue
energy values as adding new ones is faster and I do not drain the queue, just
return when reached final state.

TODO:
 - According to profiling hashing the states for the `std.AutoHashMap` which
strores the already visited states is the slow part.
 - Maybe try using [BTreeMap](https://github.com/pmkap/zig-btreemap)
 - Use A* heuristics for choosing better states to check, do not wast time on
useless states.