day 18 (#36)

Author: FrederikTobner

.github/workflows/Doxygen.yaml

@@ -0,0 +1,23 @@
+name: Documentation
+
+on:
+  push:
+    branches: [master ]
+
+jobs:
+  build:
+    name: Build and publish documentation
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install Doxygen
+      run:  sudo apt-get install doxygen
+    - name: Generate documentation
+      run: doxygen
+    - name: Deploy to GitHub Pages
+      uses: Cecilapp/GitHub-Pages-deploy@v3
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        email: ${{secrets.EMAIL}}
+        build_dir: ./docs/html

Doxyfile

@@ -8,23 +8,23 @@ namespace aoc::day_16 {
 /// @brief Parses the maze from the input
 /// @param lines The input to parse
 /// @return The parsed maze
-auto parseMaze(std::vector<std::string_view> lines) -> std::vector<std::vector<maze_cell>> {
-    std::vector<std::vector<maze_cell>> maze;
+auto parseMaze(std::vector<std::string_view> lines) -> std::vector<std::vector<aoc::path_finding::maze_cell>> {
+    std::vector<std::vector<aoc::path_finding::maze_cell>> maze;
     for (auto const & line : lines) {
-        std::vector<maze_cell> row;
+        std::vector<aoc::path_finding::maze_cell> row;
         for (auto const & cell : line) {
             switch (cell) {
             case '#':
-                row.push_back(maze_cell::WALL);
+                row.push_back(aoc::path_finding::maze_cell::WALL);
                 break;
             case '.':
-                row.push_back(maze_cell::EMPTY);
+                row.push_back(aoc::path_finding::maze_cell::EMPTY);
                 break;
             case 'S':
-                row.push_back(maze_cell::START);
+                row.push_back(aoc::path_finding::maze_cell::START);
                 break;
             case 'E':
-                row.push_back(maze_cell::END);
+                row.push_back(aoc::path_finding::maze_cell::END);
                 break;
             default:
                 throw std::invalid_argument("Invalid cell type in maze");

day_16/lib/maze.cpp

@@ -3,13 +3,13 @@
 #include <string_view>
 #include <vector>
 
-#include "maze_cell.hpp"
+#include "../../shared/src/maze_cell.hpp"
 
 namespace aoc::day_16 {
 
 /// @brief Parses the maze from the input
 /// @param lines The input to parse
 /// @return The parsed maze
-auto parseMaze(std::vector<std::string_view> lines) -> std::vector<std::vector<maze_cell>>;
+auto parseMaze(std::vector<std::string_view> lines) -> std::vector<std::vector<aoc::path_finding::maze_cell>>;
 
 } // namespace aoc::day_16

day_16/lib/maze.hpp

@@ -5,12 +5,12 @@
 #include <unordered_set>
 #include <vector>
 
+#include "../../shared/src/astar.hpp"
 #include "../../shared/src/exit_code.hpp"
 #include "../../shared/src/file_operations.hpp"
 #include "../../shared/src/grid_processor.hpp"
 #include "../../shared/src/print_compatibility_layer.hpp"
 
-#include "../lib/astar.hpp"
 #include "../lib/maze.hpp"
 
 auto main(int argc, char const ** argv) -> int {
@@ -29,9 +29,12 @@ auto main(int argc, char const ** argv) -> int {
 
     auto maze = aoc::day_16::parseMaze(grid);
 
-    // Part 1
+    auto scoringFun = [](aoc::path_finding::Node const & a, aoc::path_finding::Node const & b) {
+        return a.direction == b.direction ? 1 : 1001;
+    };
 
-    auto shortest_route = aoc::day_16::MazeSolver(maze).findPath();
+    // Part 1
+    auto shortest_route = aoc::path_finding::MazeSolver(maze, scoringFun).findPath();
 
     if (shortest_route.cost == -1) {
         std::println("No path found");
@@ -41,7 +44,7 @@ auto main(int argc, char const ** argv) -> int {
 
     // Part 2
 
-    auto shortest_routes = aoc::day_16::MazeSolver(maze).findPaths();
+    auto shortest_routes = aoc::path_finding::MazeSolver(maze, scoringFun).findPaths();
 
     std::println("Found {} paths", shortest_routes.size());
 

day_16/src/main.cpp

@@ -3,6 +3,7 @@
 #include <gtest/gtest.h>
 
 using namespace aoc::day_16;
+using namespace aoc::path_finding;
 using ::testing::ElementsAre;
 
 TEST(MazeTest, ParsesEmptyMaze) {

day_16/test/maze_test.cpp

@@ -0,0 +1 @@
+aoc_day(18)

day_18/CMakeLists.txt

@@ -0,0 +1 @@
+aoc_add_library()

day_18/lib/CMakeLists.txt

@@ -0,0 +1,27 @@
+#include "blocker.hpp"
+
+#include <algorithm>
+#include <ranges>
+
+namespace aoc::day_18 {
+
+auto scoringFun(aoc::path_finding::Node const & a, aoc::path_finding::Node const & b) -> int {
+    return 1;
+}
+
+auto validatePath(maze const & maze, auto const & scoringFun) -> bool {
+    auto shortest_route = aoc::path_finding::MazeSolver(maze.m_maze, scoringFun).findPath();
+    return shortest_route.cost == -1;
+}
+
+auto findCriticalWall(std::vector<std::vector<int16_t>> const & coordinates, size_t min)
+    -> std::pair<int16_t, int16_t> {
+    for (auto i : std::views::iota(min, coordinates.size()) | std::views::reverse) {
+        auto test_maze = buildMaze(coordinates, i);
+        if (!validatePath(test_maze, scoringFun)) {
+            return {coordinates[i][0], coordinates[i][1]};
+        }
+    }
+    return {-1, -1};
+}
+} // namespace aoc::day_18

day_18/lib/blocker.cpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "maze.hpp"
+
+#include "../../shared/src/astar.hpp"
+
+namespace aoc::day_18 {
+
+/// @brief Scoring function for A* pathfinding
+/// @param a First node
+/// @param b Second node
+/// @return Cost between nodes
+auto scoringFun(aoc::path_finding::Node const & a, aoc::path_finding::Node const & b) -> int;
+
+/// @brief Validates if a path exists through the maze
+/// @param maze The maze to validate
+/// @param scoringFun Function used to score path segments
+/// @return True if no path exists, false otherwise
+auto validatePath(maze const & maze, auto const & scoringFun) -> bool;
+
+/// @brief Finds the critical wall that blocks all paths
+/// @param coordinates Vector of coordinate pairs
+/// @param min Minimum index to start searching from
+/// @return Pair of coordinates for the critical wall, or {-1,-1} if none found
+auto findCriticalWall(std::vector<std::vector<int16_t>> const & coordinates, size_t min = 1025ull)
+    -> std::pair<int16_t, int16_t>;
+} // namespace aoc::day_18

day_18/lib/blocker.hpp

@@ -0,0 +1,54 @@
+#include "maze.hpp"
+
+#include <ranges>
+#include <string>
+#include <vector>
+
+#include "../../shared/src/maze_cell.hpp"
+
+namespace aoc::day_18 {
+
+#define DIMENSIONS 71
+
+maze::maze() {
+    m_maze = std::vector<std::vector<aoc::path_finding::maze_cell>>(
+        DIMENSIONS, std::vector<aoc::path_finding::maze_cell>(DIMENSIONS, aoc::path_finding::maze_cell::EMPTY));
+    m_maze[0][0] = aoc::path_finding::maze_cell::START;
+    m_maze[DIMENSIONS - 1][DIMENSIONS - 1] = aoc::path_finding::maze_cell::END;
+}
+
+std ::string maze::to_string() {
+    std::string result;
+    for (size_t y = 0; y < DIMENSIONS; ++y) {
+        for (size_t x = 0; x < DIMENSIONS; ++x) {
+            switch (m_maze[x][y]) {
+            case aoc::path_finding::maze_cell::EMPTY:
+                result += ".";
+                break;
+            case aoc::path_finding::maze_cell::WALL:
+                result += "#";
+                break;
+            case aoc::path_finding::maze_cell::START:
+                result += "S";
+                break;
+            case aoc::path_finding::maze_cell::END:
+                result += "E";
+                break;
+            }
+        }
+        result += "\n";
+    }
+    return result;
+}
+
+auto buildMaze(std::vector<std::vector<int16_t>> const & coordinates, size_t limit) -> maze {
+    auto result = maze{};
+    for (auto const & [x, y] : coordinates | std::views::take(limit) | std::views::transform([](auto const & line) {
+                                   return std::pair{line[0], line[1]};
+                               })) {
+        result.m_maze[x][y] = aoc::path_finding::maze_cell::WALL;
+    }
+    return result;
+}
+
+} // namespace aoc::day_18

day_18/lib/maze.cpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <ranges>
+#include <string>
+#include <vector>
+
+#include "../../shared/src/maze_cell.hpp"
+
+namespace aoc::day_18 {
+
+#define DIMENSIONS 71
+
+/// @brief Represents a 2D maze with start and end points
+struct maze {
+    /// @brief Constructs an empty maze with start and end points
+    maze();
+
+    /// @brief Converts the maze to a string representation
+    /// @return String representation of the maze
+    std ::string to_string();
+
+    /// @brief The actual maze data
+    std::vector<std::vector<aoc::path_finding::maze_cell>> m_maze;
+};
+
+/// @brief Builds a maze from coordinate pairs
+/// @param coordinates Vector of coordinate pairs
+/// @param limit Maximum number of coordinates to use
+/// @return Constructed maze
+auto buildMaze(std::vector<std::vector<int16_t>> const & coordinates, size_t limit) -> maze;
+
+} // namespace aoc::day_18

day_18/lib/maze.hpp

@@ -0,0 +1,21 @@
+#include "parser.hpp"
+
+#include <execution>
+
+#include "../../shared/src/file_operations.hpp"
+#include "../../shared/src/line_splitter.hpp"
+#include "../../shared/src/parsing_rules.hpp"
+
+namespace aoc::day_18 {
+
+auto parseInput(std::string_view filename) -> std::expected<std::vector<std::vector<int16_t>>, std::error_code> {
+    auto input = aoc::file_operations::read(filename);
+    if (!input) {
+        return std::unexpected(input.error());
+    }
+
+    return aoc::splitter::linebased::split<int16_t, std::vector>(*input, aoc::parser::rules::parse_number<int16_t>,
+                                                                 std::execution::seq, ',');
+}
+
+} // namespace aoc::day_18

day_18/lib/parser.cpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstdint>
+#include <expected>
+#include <string_view>
+#include <system_error>
+#include <vector>
+
+namespace aoc::day_18 {
+
+/// @brief Parses the input file containing coordinate pairs
+/// @param filename Path to the input file
+/// @return Vector of coordinate pairs on success, error code on failure
+auto parseInput(std::string_view filename) -> std::expected<std::vector<std::vector<int16_t>>, std::error_code>;
+
+} // namespace aoc::day_18

day_18/lib/parser.hpp

@@ -0,0 +1,2 @@
+aoc_add_executable()
+configure_file(input.txt input.txt COPYONLY)