174 lines
4.3 KiB
C++
174 lines
4.3 KiB
C++
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <fstream>
|
|
#include <iterator>
|
|
#include <stdexcept>
|
|
#include <vector>
|
|
#include <set>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <bitset>
|
|
#include <queue>
|
|
#include <cctype>
|
|
#include <queue>
|
|
#include <map>
|
|
|
|
#include <aocpp/Startup.hpp>
|
|
#include <aocpp/Coord.hpp>
|
|
#include <aocpp/Grid.hpp>
|
|
|
|
using namespace aocpp;
|
|
|
|
// lowercase key
|
|
// uppercase door
|
|
// start at @
|
|
// wall #
|
|
// boring .
|
|
|
|
namespace {
|
|
|
|
Coord(* const directions[4])(Coord) = {Up, Down, Left, Right};
|
|
|
|
using Features = std::map<char, Coord>;
|
|
using Doors = std::bitset<26>;
|
|
using Distances = std::map<char,std::map<char, std::pair<std::int64_t, Doors>>>;
|
|
|
|
auto SetKey(Doors& doors, char key) {
|
|
return doors.set(std::toupper(key) - 'A');
|
|
}
|
|
|
|
auto FindFeatures(Grid const& grid) -> Features {
|
|
Features features;
|
|
for (auto [c, v] : grid) {
|
|
if ('#' != v && '.' != v) {
|
|
features[v] = c;
|
|
}
|
|
}
|
|
return features;
|
|
}
|
|
|
|
auto FindDistancesFrom(
|
|
Grid const& grid,
|
|
char const start_letter,
|
|
Coord const start
|
|
) {
|
|
std::map<char, std::pair<std::int64_t, Doors>> result;
|
|
|
|
std::queue<std::tuple<std::int64_t, Coord, Doors>> todo;
|
|
todo.push({0, start, {}});
|
|
|
|
std::set<Coord> seen;
|
|
|
|
for (; !todo.empty(); todo.pop()) {
|
|
auto [steps, here, doors] = todo.front();
|
|
|
|
// Don't visit the same coordinate twice
|
|
if (!seen.insert(here).second) continue;
|
|
|
|
auto const c = grid[here];
|
|
if (c == '#') continue; // avoid walls
|
|
|
|
// success, we've found a key, record the path
|
|
if (c != start_letter && std::islower(c)) {
|
|
result[c] = {steps, doors};
|
|
continue; // don't walk beyond the key
|
|
}
|
|
|
|
// Note any keys we encounter on our journey
|
|
if (std::isupper(c)) {
|
|
SetKey(doors, c);
|
|
}
|
|
|
|
// Visit all neighbors
|
|
for (auto const fn : directions) {
|
|
todo.emplace(steps+1, fn(here), doors);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
auto FindDistances(Grid const& grid, Features const& features) {
|
|
Distances distances;
|
|
for (auto const [start_letter, start_coord] : features) {
|
|
if (!std::isupper(start_letter)) {
|
|
distances[start_letter] = FindDistancesFrom(grid, start_letter, start_coord);
|
|
}
|
|
}
|
|
return distances;
|
|
}
|
|
|
|
auto SolveMaze(
|
|
Distances const& distances,
|
|
std::string const initial_locations
|
|
) -> std::int64_t
|
|
{
|
|
// Track current positions and current set of keys in easy to compare form
|
|
using Visited = std::pair<std::string, unsigned long long>;
|
|
std::set<Visited> seen;
|
|
|
|
// Priority queue returning lowest path cost states first.
|
|
using PqElt = std::tuple<std::int64_t, std::string, Doors>;
|
|
using PqCmp = decltype([](PqElt const& x, PqElt const& y) {
|
|
return std::get<0>(x) > std::get<0>(y); });
|
|
std::priority_queue<PqElt, std::vector<PqElt>, PqCmp> todo;
|
|
|
|
todo.emplace(0, initial_locations, Doors());
|
|
|
|
while(!todo.empty()) {
|
|
auto [steps, locations, keys] = todo.top();
|
|
todo.pop();
|
|
|
|
if (keys.all()) { return steps; }
|
|
|
|
std::sort(locations.begin(), locations.end());
|
|
if (seen.emplace(locations, keys.to_ullong()).second) {
|
|
|
|
for (auto& location : locations) {
|
|
auto const save = location;
|
|
|
|
for (auto const& [next, costneed] : distances.at(location)) {
|
|
auto const [cost, need] = costneed;
|
|
if ((need & ~keys).none()) { // no missing keys
|
|
location = next;
|
|
auto keys_ = keys; SetKey(keys_, next);
|
|
todo.emplace(steps + cost, locations, keys_);
|
|
location = save;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error{"no solution to part 1"};
|
|
}
|
|
|
|
// Part 2 instructs us to update the map splitting it into 4 quadrants
|
|
auto Part2(Grid & grid, Features & features) {
|
|
auto const start = features['@'];
|
|
for (auto const fn : directions) {
|
|
grid[fn(start)] = '#';
|
|
}
|
|
features.erase('@');
|
|
features['^'] = Up(Left (start));
|
|
features['&'] = Down(Left (start));
|
|
features['*'] = Up(Right(start));
|
|
features['$'] = Down(Right(start));
|
|
}
|
|
|
|
} // namespace
|
|
|
|
auto Main(std::istream & in, std::ostream & out) -> void
|
|
{
|
|
auto grid = Grid::Parse(in);
|
|
auto features = FindFeatures(grid);
|
|
auto distances = FindDistances(grid, features);
|
|
out << "Part 1: " << SolveMaze(distances, "@") << std::endl;
|
|
|
|
Part2(grid, features);
|
|
distances = FindDistances(grid, features);
|
|
out << "Part 2: " << SolveMaze(distances, "^&*$") << std::endl;
|
|
}
|