Add 2023 days 20-25 cpp

Author: vss2sn

2023/README.md

@@ -27,3 +27,9 @@ This folder contains solutions to each of the problems in Advent of Code 2023 in
 | <nobr> [Day 17: Clumsy Crucible](https://adventofcode.com/2023/day/17) </nobr> | <nobr> [Part 1](/2023/cpp/day_17a.cpp) [Part 2](/2023/cpp/day_17b.cpp) </nobr> | </nobr> [Link](/2023/input/day_17_input) </nobr> | </nobr> [Link](/2023/sample_input/day_17_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_17_puzzle) </nobr> |
 | <nobr> [Day 18: Lavaduct Lagoon](https://adventofcode.com/2023/day/18) </nobr> | <nobr> [Part 1](/2023/cpp/day_18a.cpp) [Part 2](/2023/cpp/day_18b.cpp) </nobr> | </nobr> [Link](/2023/input/day_18_input) </nobr> | </nobr> [Link](/2023/sample_input/day_18_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_18_puzzle) </nobr> |
 | <nobr> [Day 19: Aplenty](https://adventofcode.com/2023/day/19) </nobr> | <nobr> [Part 1](/2023/cpp/day_19a.cpp) [Part 2](/2023/cpp/day_19b.cpp) </nobr> | </nobr> [Link](/2023/input/day_19_input) </nobr> | </nobr> [Link](/2023/sample_input/day_19_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_19_puzzle) </nobr> |
+| <nobr> [Day 20: Pulse Propagation](https://adventofcode.com/2023/day/20) </nobr> | <nobr> [Part 1](/2023/cpp/day_20a.cpp) [Part 2](/2023/cpp/day_20b.cpp) </nobr> | </nobr> [Link](/2023/input/day_20_input) </nobr> | </nobr> [Link](/2023/sample_input/day_20_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_20_puzzle) </nobr> |
+| <nobr> [Day 21: Step Counter](https://adventofcode.com/2023/day/21) </nobr> | <nobr> [Part 1](/2023/cpp/day_21a.cpp) [Part 2](/2023/cpp/day_21b.cpp) </nobr> | </nobr> [Link](/2023/input/day_21_input) </nobr> | </nobr> [Link](/2023/sample_input/day_21_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_21_puzzle) </nobr> |
+| <nobr> [Day 22: Sand Slabs](https://adventofcode.com/2023/day/22) </nobr> | <nobr> [Part 1](/2023/cpp/day_22a.cpp) [Part 2](/2023/cpp/day_22b.cpp) </nobr> | </nobr> [Link](/2023/input/day_22_input) </nobr> | </nobr> [Link](/2023/sample_input/day_22_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_22_puzzle) </nobr> |
+| <nobr> [Day 23: A Long Walk](https://adventofcode.com/2023/day/23) </nobr> | <nobr> [Part 1](/2023/cpp/day_23a.cpp) [Part 2](/2023/cpp/day_23b.cpp) </nobr> | </nobr> [Link](/2023/input/day_23_input) </nobr> | </nobr> [Link](/2023/sample_input/day_23_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_23_puzzle) </nobr> |
+| <nobr> [Day 24: Never Tell Me The Odds](https://adventofcode.com/2023/day/24) </nobr> | <nobr> [Part 1](/2023/cpp/day_24a.cpp) [Part 2](/2023/cpp/day_24b.cpp) </nobr> | </nobr> [Link](/2023/input/day_24_input) </nobr> | </nobr> [Link](/2023/sample_input/day_24_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_24_puzzle) </nobr> |
+| <nobr> [Day 25: Snowverload](https://adventofcode.com/2023/day/25) </nobr> | <nobr> [Part 1](/2023/cpp/day_25a.cpp) | </nobr> [Link](/2023/input/day_25_input) </nobr> | </nobr> [Link](/2023/sample_input/day_25_sample_input) </nobr> | </nobr> [Link](/2023/puzzles/day_25_puzzle) </nobr> |

2023/cpp/day_20a.cpp

@@ -0,0 +1,207 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cassert> 
+#include <memory>
+
+struct Module {
+  std::string name;
+  std::vector<std::string> to_modules;
+  std::vector<std::string> from_modules;
+  virtual std::vector<std::pair<std::string, bool>> evaluate(const std::string& source, const bool is_high) {
+    return {};
+  };
+  virtual void setup() {};
+}; 
+
+struct FF : public Module {
+  bool state = false;
+  std::vector<std::pair<std::string, bool>>  evaluate(const std::string& source, const bool is_high) override {
+    // std::cout << __LINE__ << '\n'; 
+
+    std::vector<std::pair<std::string, bool>> return_values;
+    if (!is_high) {
+      state = !state;
+      for (const auto& to : to_modules) {
+          // std::cout << "TO: " << to << '\n';
+        return_values.emplace_back(to, state);
+      }
+    }
+    // std::cout << __LINE__ << '\n'; 
+    return return_values;
+  }
+};
+
+struct Conjunction : public Module {
+  std::unordered_map<std::string, bool> state;
+  std::vector<std::pair<std::string, bool>>  evaluate(const std::string& source, const bool is_high) override {
+    state[source] = is_high;
+    bool is_low = false;
+    bool output_value = true;
+    for (const auto& [name, value] : state) {
+      // std::cout << name << ' ' << value << '\n';
+      if (!value) {
+        is_low = true;
+        break;
+      }
+    }
+    if(!is_low) output_value = false;
+    std::vector<std::pair<std::string, bool>> return_values;
+    for (const auto& to : to_modules) {
+      // std::cout << "TO: " << to << '\n';
+      return_values.emplace_back(to, output_value);
+    }
+    return return_values;
+  }
+  void setup() override {
+    for (const auto& from : from_modules) {
+      state[from] = false;
+    }
+  }
+};
+
+struct Broadcaster : public Module {
+  std::vector<std::pair<std::string, bool>>  evaluate(const std::string& source, const bool is_high) override {
+    std::vector<std::pair<std::string, bool>> return_values;
+    for (const auto& to : to_modules) {
+      // std::cout << "TO: " << to << '\n';
+      return_values.emplace_back(to, is_high);
+    }
+    return return_values;
+  }
+};
+
+std::unique_ptr<Module> create_module (const std::string& name, const std::vector<std::string>& connected_to) {  
+  std::unique_ptr<Module> m_ptr;
+  if(name[0] == '%') {
+    FF m;
+    m.name = name.substr(1, name.size() - 1);
+    m.to_modules = connected_to;
+    m_ptr = std::make_unique<FF>(m);
+  } else if(name[0] == '&') {
+    Conjunction m;
+    m.name = name.substr(1, name.size() - 1);
+    m.to_modules = connected_to;
+    m_ptr = std::make_unique<Conjunction>(m);
+  } else if (name == "broadcaster") {
+    Broadcaster m;
+    m.name = "broadcaster";
+    m.to_modules = connected_to;
+    m_ptr = std::make_unique<Broadcaster>(m);
+  } 
+  // std::cout << "Created " << m_ptr->name << '\n';
+  return m_ptr;
+}
+
+std::vector<std::string> extract_connected_to(const std::string& s) {
+  // std::cout << "|" << s << "|" << '\n';
+  std::vector<std::string> substrs;
+
+  std::size_t start = 0;
+  std::size_t end = s.find(',', start);
+  while (end != std::string::npos) {
+    substrs.push_back(s.substr(start, end - start));
+    start = end + 2;
+    end = s.find(',', start);
+  }
+  substrs.push_back(s.substr(start, s.size() - start));
+  // std::cout << '|';
+  // for (const auto s : substrs) {
+  //   std::cout << s << "|";
+  // }
+  // std::cout << '\n';
+  return substrs;
+}
+
+std::pair<std::string, std::vector<std::string>> parse (const std::string& line) {
+  const auto idx = line.find(' ');
+  return {line.substr(0, idx), extract_connected_to(line.substr(idx+4, line.size() - idx - 4))};
+}
+
+struct Pulse {
+  std::string from;
+  std::string to;
+  bool value;
+};
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_20_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::unordered_map<std::string, std::unique_ptr<Module>> modules;
+  while(std::getline(file, line)) {
+    const auto [name_with_type, connected_to] = parse (line);
+    auto tmp = create_module(name_with_type, connected_to);
+    modules[tmp->name] = std::move(tmp);
+    // std::cout << __LINE__ << '\n';
+  }
+   
+  for (const auto& [name, module] : modules) {
+    for (const auto& to : module->to_modules) {
+      if (modules.find(to) == modules.end()) {
+        Module m;
+        m.name = to;
+        modules[to] = std::make_unique<Module>(std::move(m));
+      }
+      // std::cout << __LINE__ << '\n';
+      modules[to]->from_modules.push_back(module->name);  
+      // std::cout << __LINE__ << '\n';
+    }
+  }
+
+  for (const auto& [name, module] : modules) {
+    // std::cout << __LINE__ << '\n';
+    module->setup();
+    // std::cout << __LINE__ << '\n';
+  }
+
+  std::size_t low_count = 0;
+  std:;size_t high_count = 0;
+  for (int i = 0; i < 1000; i++) {
+    // std::cout << "Press button" << '\n';
+    std::queue<Pulse> to_process; 
+    {
+      Pulse p;
+      p.from = "button";
+      p.to = "broadcaster";
+      p.value = false;
+      to_process.push(p);
+    }
+    // std::cout << __LINE__ << '\n';
+    while (!to_process.empty()) {
+      const auto pulse = to_process.front();
+      to_process.pop();
+      // std::cout << "Processing " << pulse.from <<" -" << (pulse.value ? "high" : "low") << "-> " << pulse.to << '\n';
+      if(pulse.value) {
+        high_count++;
+      } else {
+        low_count++;
+      }
+      // std::cout << __LINE__ << '\n'; 
+      const auto modules_to_process = modules[pulse.to]->evaluate(pulse.from, pulse.value);
+      // std::cout << __LINE__ << '\n'; 
+
+      for (const auto module_to_process : modules_to_process) {
+        // std::cout << module_to_process.first << '\n';
+        Pulse new_pulse;
+        new_pulse.from = pulse.to;
+        new_pulse.to = module_to_process.first;
+        new_pulse.value = module_to_process.second;
+        to_process.push(new_pulse);
+      }
+    }
+  }
+  // std::cout << high_count << ' ' << low_count << '\n';
+  std::cout << low_count * high_count << '\n';
+  return 0;
+}

2023/cpp/day_20b.cpp

@@ -0,0 +1,214 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cassert> 
+#include <memory>
+
+struct Module {
+  std::string name;
+  std::vector<std::string> to_modules;
+  std::vector<std::string> from_modules;
+  virtual std::vector<std::pair<std::string, bool>> evaluate(const std::string& source, const bool is_high) {
+    return {};
+  };
+  virtual void setup() {};
+}; 
+
+struct FF : public Module {
+  bool state = false;
+  std::vector<std::pair<std::string, bool>>  evaluate(const std::string& source, const bool is_high) override {
+    std::vector<std::pair<std::string, bool>> return_values;
+    if (!is_high) {
+      state = !state;
+      for (const auto& to : to_modules) {
+          // std::cout << "TO: " << to << '\n';
+        return_values.emplace_back(to, state);
+      }
+    }
+    return return_values;
+  }
+};
+
+struct Conjunction : public Module {
+  std::unordered_map<std::string, bool> state;
+  std::vector<std::pair<std::string, bool>>  evaluate(const std::string& source, const bool is_high) override {
+    state[source] = is_high;
+    bool is_low = false;
+    bool output_value = true;
+    for (const auto& [name, value] : state) {
+      if (!value) {
+        is_low = true;
+        break;
+      }
+    }
+    if(!is_low) output_value = false;
+    std::vector<std::pair<std::string, bool>> return_values;
+    for (const auto& to : to_modules) {
+      // std::cout << "TO: " << to << '\n';
+      return_values.emplace_back(to, output_value);
+    }
+    return return_values;
+  }
+  void setup() override {
+    for (const auto& from : from_modules) {
+      state[from] = false;
+    }
+  }
+};
+
+struct Broadcaster : public Module {
+  std::vector<std::pair<std::string, bool>>  evaluate(const std::string& source, const bool is_high) override {
+    std::vector<std::pair<std::string, bool>> return_values;
+    for (const auto& to : to_modules) {
+      // std::cout << "TO: " << to << '\n';
+      return_values.emplace_back(to, is_high);
+    }
+    return return_values;
+  }
+};
+
+std::unique_ptr<Module> create_module (const std::string& name, const std::vector<std::string>& connected_to) {  
+  std::unique_ptr<Module> m_ptr;
+  if(name[0] == '%') {
+    FF m;
+    m.name = name.substr(1, name.size() - 1);
+    m.to_modules = connected_to;
+    m_ptr = std::make_unique<FF>(m);
+  } else if(name[0] == '&') {
+    Conjunction m;
+    m.name = name.substr(1, name.size() - 1);
+    m.to_modules = connected_to;
+    m_ptr = std::make_unique<Conjunction>(m);
+  } else if (name == "broadcaster") {
+    Broadcaster m;
+    m.name = "broadcaster";
+    m.to_modules = connected_to;
+    m_ptr = std::make_unique<Broadcaster>(m);
+  } 
+  return m_ptr;
+}
+
+std::vector<std::string> extract_connected_to(const std::string& s) {
+  std::vector<std::string> substrs;
+
+  std::size_t start = 0;
+  std::size_t end = s.find(',', start);
+  while (end != std::string::npos) {
+    substrs.push_back(s.substr(start, end - start));
+    start = end + 2;
+    end = s.find(',', start);
+  }
+  substrs.push_back(s.substr(start, s.size() - start));
+  return substrs;
+}
+
+std::pair<std::string, std::vector<std::string>> parse (const std::string& line) {
+  const auto idx = line.find(' ');
+  return {line.substr(0, idx), extract_connected_to(line.substr(idx+4, line.size() - idx - 4))};
+}
+
+struct Pulse {
+  std::string from;
+  std::string to;
+  bool value;
+};
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_20_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::unordered_map<std::string, std::unique_ptr<Module>> modules;
+  while(std::getline(file, line)) {
+    const auto [name_with_type, connected_to] = parse (line);
+    auto tmp = create_module(name_with_type, connected_to);
+    modules[tmp->name] = std::move(tmp);
+    // std::cout << __LINE__ << '\n';
+  }
+   
+  for (const auto& [name, module] : modules) {
+    for (const auto& to : module->to_modules) {
+      if (modules.find(to) == modules.end()) {
+        Module m;
+        m.name = to;
+        modules[to] = std::make_unique<Module>(std::move(m));
+      }
+      // std::cout << __LINE__ << '\n';
+      modules[to]->from_modules.push_back(module->name);  
+      // std::cout << __LINE__ << '\n';
+    }
+  }
+
+  std::unordered_map<std::string, std::size_t> periods;
+  // By inspection it can be seen that rx needs to receive a single pulse from bb (the only module it is connected to)
+  // Hence bb needs to receive and remember high pulses from the modules it is connected to 
+  // Debug: bb is connected to:
+  for (const auto& ele :  modules[modules["rx"]->from_modules[0]]->from_modules ) {
+  //   std::cout << ele << " | ";
+   periods[ele] = 0; 
+  }
+  // std::cout << '\n';
+  for (const auto& [name, module] : modules) {
+    module->setup();
+  }
+
+  std::size_t low_count = 0;
+  std::size_t high_count = 0;
+  int count = 0;
+  for (int i = 0; i < 100000000; i++) {
+    // std::cout << "Press button" << '\n';
+    std::queue<Pulse> to_process; 
+    {
+      Pulse p;
+      p.from = "button";
+      p.to = "broadcaster";
+      p.value = false;
+      to_process.push(p);
+    }
+    while (!to_process.empty()) {
+      const auto pulse = to_process.front();
+      to_process.pop();
+      // std::cout << "Processing " << pulse.from <<" -" << (pulse.value ? "high" : "low") << "-> " << pulse.to << '\n';
+      if(pulse.value) {
+        high_count++;
+      } else {
+        low_count++;
+      }
+      if (pulse.value && (periods.find(pulse.from) != periods.end())) {
+        if (periods[pulse.from] == 0) {
+          periods[pulse.from] = i;
+          count++;
+        }
+        if (count == 4) {
+          std::size_t ans = 1;
+          for (auto& [name, val] : periods) {
+            val+=1; // Since pulse count (i) started from 0
+            ans = std::lcm(ans, val);
+          }
+          std::cout << ans << '\n';
+          return 0;
+        }
+      }
+
+      const auto modules_to_process = modules[pulse.to]->evaluate(pulse.from, pulse.value);
+      for (const auto module_to_process : modules_to_process) {
+        // std::cout << module_to_process.first << '\n';
+        Pulse new_pulse;
+        new_pulse.from = pulse.to;
+        new_pulse.to = module_to_process.first;
+        new_pulse.value = module_to_process.second;
+        to_process.push(new_pulse);
+      }
+    }
+  }
+  return 0;
+}

2023/cpp/day_21a.cpp

@@ -0,0 +1,103 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cassert> 
+#include <memory>
+
+constexpr int n = 64;
+
+struct PointState {
+  int row;
+  int col;
+  int step;
+
+  PointState(const int row = 0, const int col = 0, const int step = 0) : row(row), col(col), step(step) {}
+
+  PointState operator + (const PointState& p) const {
+    return PointState (p.row + row,  p.col + col, p.step + step);
+  }
+
+  bool operator == (const PointState& p) const {
+    return p.row == row && p.col == col && p.step == step;
+  }
+};
+
+struct hasher {
+  std::size_t operator() (const PointState& ps) const {
+    return ps.row + ps.col;
+  }
+};
+
+const std::vector<PointState> motions {
+  PointState(-1,0,1),
+  PointState(0,1,1),
+  PointState(1,0,1),
+  PointState(0, -1,1),
+};
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_21_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::vector<std::string> map;
+  int step = 0;
+  PointState S;
+  while(std::getline(file, line)) {
+    map.push_back(line);
+    for (int i = 0; i < line.size(); i++) {
+      if (line[i] == 'S') {
+        S.row = map.size() - 1;
+        S.col = i;
+        S.step = 0;
+      }
+    }
+  }
+  std::queue<PointState> queue;
+  std::unordered_set<PointState, hasher> seen;
+  std::unordered_set<PointState, hasher> end_states;
+  queue.push(S);
+  while(!queue.empty()) {
+    const auto current = queue.front();
+    queue.pop();
+    if (seen.find(current) != seen.end()) {
+      continue;
+    }
+    if (current.step > n) continue;
+    if (current.step == n) end_states.insert(current);
+    seen.insert(current);
+    for (const auto& motion : motions) {
+      const auto new_state = current + motion;
+      if (new_state.row >= map.size() || new_state.row < 0 || new_state.col < 0 || new_state.col >= map[0].size()) {
+        continue;
+      }
+      if (map[new_state.row][new_state.col] == '#') {
+        continue;
+      }
+      queue.push(new_state);
+    }
+  }
+  for (const auto & end_state : end_states) {
+    map[end_state.row][end_state.col] = 'O';
+  }
+  int count = 0;
+  for (const auto& row : map) {
+    std::cout << row << '\n';
+    for (const auto c : row) {
+      if (c == 'O') {
+        count++;
+      }
+    }
+  }
+  std::cout << count << '\n';
+  return 0;
+}

2023/cpp/day_21b.cpp

@@ -0,0 +1,203 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cassert> 
+#include <memory>
+
+// This will work with both the sample input and the main input
+// The core idea here is that the edges of the square grid are always empty
+// This leads to a highway that can be used to reach grids 
+// further away from the starting point
+// At some unknown distance it becomes more efficient to 
+// 1. move from the starting point to the highway
+// 2. traverse the highway to the target point's grid
+// 3. move from the highway to the target point
+// instead of going through the grids between the start and end point
+// Let this distance cover `heuristic_1` grids
+// So up until that heuristic brute force is used to find the number of reachable points.
+// 
+// The infinite grid can be represented as 
+//   ^^^^^
+//   |||||
+// <-CEEEC->
+// <-E...E->
+// <-E...E->
+// <-E...E->
+// <-CEEEC->
+//   |||||
+//   vvvvv
+// where the `.`s are bruteforced 
+// the edges `E` represent all the the points in the infinite grid as represented by the arrows next to them
+// the corners `C` represent all the the points in the infinite grid as represented and enclosed by the arrows next to them 
+// 
+// Reference:
+// https://github.com/jonathanpaulson/AdventOfCode/blob/master/2023/21.py
+
+constexpr int heuristic_1 = 4;
+constexpr std::size_t n_steps = 26501365;
+
+struct Point {
+  int tile_row;
+  int tile_col;
+  int row;
+  int col;
+  std::size_t step;
+  std::size_t hash;
+
+  Point(const int tile_row = 0, const int tile_col = 0, const int row = 0, const int col = 0, const int step = 0) : tile_row(tile_row), tile_col(tile_col), row(row), col(col), step(step) {
+    hash = tile_row * tile_col * 10000 + row * col;
+  }
+
+  Point operator + (const Point& p) const {
+    return Point (p.tile_row + tile_row, p.tile_col + tile_col, p.row + row,  p.col + col, p.step + step);
+  }
+
+  bool operator == (const Point& p) const {
+    return p.tile_row == tile_row && p.tile_col == tile_col && p.row == row && p.col == col && p.step == step;
+  }
+  void update_hash() {
+    hash = tile_row * tile_col * 10000 + row * col;
+  }
+};
+
+struct hasher {
+  std::size_t operator() (const Point& ps) const {
+    return ps.hash;
+  }
+};
+
+const std::vector<Point> motions {
+  Point(0,0,-1,0,0),
+  Point(0,0,0,1,0),
+  Point(0,0,1,0,0),
+  Point(0,0,0,-1,0),
+};
+
+// Should replace point with another struct here
+std::unordered_map<Point, std::size_t, hasher> temp_map;
+std::size_t helper(const std::size_t& step, const int increment, const std::size_t& n_rows) {
+    std::size_t temp = (n_steps >= step) ? (n_steps - step) / n_rows : 0;
+    // std::cout << temp << '\n';
+    if (temp_map.find(Point(step, increment,0, 0, 0)) != temp_map.end()) {
+        return temp_map[Point(step, increment, 0, 0, 0)];
+    }
+    std::size_t return_val = 0;
+    for (std::size_t idx = 1; idx <= temp; idx++) {
+        if (((step + n_rows * idx) <= n_steps) && ((step + n_rows * idx) % 2 == (n_steps % 2))) {
+            return_val += (increment == 2) ? (idx + 1) : 1;
+        }
+    }
+    temp_map[Point(step, increment, 0, 0, 0)] = return_val;
+    // std::cout << return_val << '\n';
+    return return_val;
+}
+
+std::unordered_map<Point, std::size_t, hasher> create_count_map(const std::vector<std::string>& map, const Point& S) {
+    std::queue<Point> queue;
+    std::unordered_map<Point, std::size_t, hasher> count_map;
+    const auto row_size = map.size();
+    const auto col_size = map[0].size();
+    // std::cout << row_size << ' ' << col_size << '\n';
+    // exit(0);
+    queue.push(S);
+    // std::cout << S.row << ' ' << S.col << '\n';
+    while(!queue.empty()) {
+        auto current = queue.front();
+        queue.pop();
+        // std::cout << current.tile_row << ' ' 
+        //             << current.tile_col << ' ' 
+        //             << current.row << ' ' 
+        //             << current.col << ' ' 
+        //             << current.step << '\n';
+        if (current.row < 0) {
+            current.tile_row -= 1;
+            current.row += row_size;
+        }  
+        if (current.row >= row_size) {
+            current.tile_row += 1;
+            current.row -= row_size;
+        } 
+        if (current.col < 0) {
+            current.tile_col -= 1;
+            current.col += col_size;
+        } 
+        if (current.col >= col_size) {
+            current.tile_col += 1;
+            current.col -= col_size;
+        }
+        // current.update_hash();
+        if (current.row < 0 || current.row >= row_size || current.col < 0 || current.col >= col_size || map[current.row][current.col] == '#') continue;
+        if (count_map.find(Point(current.tile_row, current.tile_col, current.row, current.col, 0)) != count_map.end()) continue;
+        if (std::abs(current.tile_row) > heuristic_1 || std::abs(current.tile_col) > heuristic_1) continue;
+        count_map[Point(current.tile_row, current.tile_col, current.row, current.col, 0)] = current.step;
+        for (const auto& motion : motions) {
+            queue.emplace(current.tile_row, current.tile_col, current.row + motion.row, current.col + motion.col, current.step + 1);
+        }
+    }
+    return count_map;
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_21_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  Point S(0,0,0,0,0);
+  std::vector<std::string> map;
+  while(std::getline(file, line)) {
+    if (line.empty()) continue;
+    map.push_back(line);
+    for (int i = 0; i < line.size(); i++) {
+      if (line[i] == 'S') {
+        S.row = map.size() - 1;
+        S.col = i;
+        S.step = 0;
+      }
+    }
+  }
+
+  // Count map already contains the tiles in the square contained by
+  // (-heuristic_1, -heuristic_1) to (heuristic_1, 1heuristic_1)
+  // inclusive of the border.
+  std::vector<int> OPT;
+  for (int i = -heuristic_1; i <= heuristic_1; i++){
+    OPT.push_back(i);
+  } 
+  const auto count_map = create_count_map(map, S);
+  std::size_t ans = 0;
+  const auto n_rows = map.size();
+  const auto n_cols = map[0].size();
+  for (int row = 0; row < n_rows; row++) {
+    for (int col = 0; col < n_cols; col++) {
+        const auto p = Point(0, 0, row, col, 0);
+        if (count_map.find(p) != count_map.end()) {            
+            for (const auto tile_row : OPT) {
+                for (const auto tile_col : OPT) {
+                    const auto step = count_map.at(Point(tile_row, tile_col, row, col, 0));
+                    // std::cout <<tile_row <<' ' << tile_col<<' ' << row<<' ' << col<<' ' << 0 << '\n';
+                    if ((step % 2) == (n_steps % 2) && step <= n_steps) {
+                        ans += 1;
+                    }
+                    if ((tile_row == -heuristic_1 || tile_row == heuristic_1) &&  (tile_col == -heuristic_1 || tile_col == heuristic_1)) {
+                        ans += helper (step, 2, n_rows);
+                    }
+                    else if ((tile_row == -heuristic_1 || tile_row == heuristic_1) || (tile_col == -heuristic_1 || tile_col == heuristic_1)) {
+                        ans += helper (step, 1, n_rows);
+                    }
+                }
+            }
+        }
+    }
+  }
+  std::cout << ans << '\n';
+  return 0;
+}

2023/cpp/day_22a.cpp

@@ -0,0 +1,175 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <stack>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <regex>
+#include <cassert>
+
+
+struct Brick {
+  std::array<int, 3> start {0,0,0};
+  std::array<int, 3> end {0,0,0};
+  int id = 0;
+  bool operator == (const Brick& b) const {
+    return b.start == start && b.end == end;
+  }
+};
+
+bool check_if_overlap(const Brick& b1, const Brick& b2) {
+  bool x_overlap = false;
+  bool y_overlap = false;
+  x_overlap = std::min(b2.start[0], b2.end[0]) <= b1.start[0] && b1.start[0] <= std::max(b2.start[0], b2.end[0]);
+  y_overlap = std::min(b2.start[1], b2.end[1]) <= b1.start[1] && b1.start[1] <= std::max(b2.start[1], b2.end[1]);
+  if (x_overlap && y_overlap) return true;
+  x_overlap = x_overlap || std::min(b2.start[0], b2.end[0]) <= b1.end[0] && b1.end[0] <= std::max(b2.start[0], b2.end[0]);
+  y_overlap = y_overlap || std::min(b2.start[1], b2.end[1]) <= b1.end[1] && b1.end[1] <= std::max(b2.start[1], b2.end[1]);
+  if (x_overlap && y_overlap) return true;
+  x_overlap = x_overlap || std::min(b1.start[0], b1.end[0]) <= b2.start[0] && b2.start[0] <= std::max(b1.start[0], b1.end[0]);
+  y_overlap = y_overlap || std::min(b1.start[1], b1.end[1]) <= b2.start[1] && b2.start[1] <= std::max(b1.start[1], b1.end[1]);
+  if (x_overlap && y_overlap) return true;
+  x_overlap = x_overlap || std::min(b1.start[0], b1.end[0]) <= b2.end[0] && b2.end[0] <= std::max(b1.start[0], b1.end[0]);
+  y_overlap = y_overlap || std::min(b1.start[1], b1.end[1]) <= b2.end[1] && b2.end[1] <= std::max(b1.start[1], b1.end[1]);
+  if (x_overlap && y_overlap) return true;
+  return false;
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_22_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  const std::regex mask_pattern(R"((-?[0-9]+),(-?[0-9]+),(-?[0-9]+)~(-?[0-9]+),(-?[0-9]+),(-?[0-9]+))");
+  std::smatch mask_match;
+  std::vector<Brick> bricks;
+  while(std::getline(file, line)) {
+    std::regex_search(line, mask_match, mask_pattern); 
+    Brick b;
+    b.id = bricks.size();
+    b.start[0] = std::stoi(mask_match[1]);
+    b.start[1] = std::stoi(mask_match[2]);
+    b.start[2] = std::stoi(mask_match[3]);
+    b.end[0] = std::stoi(mask_match[4]);
+    b.end[1] = std::stoi(mask_match[5]);
+    b.end[2] = std::stoi(mask_match[6]);
+    bricks.push_back(b);
+    // std::cout << b.start[0] << ' ' << b.start[1] << ' ' 
+    //           << b.start[2] << ' ' << b.end[0] << ' ' 
+    //           << b.end[1]<< ' ' << b.end[2] << '\n';
+  }
+  for (auto& b : bricks) {
+    if (b.start[2] > b.end[2]) {
+      std::swap(b.start, b.end);
+    }
+  }
+  std::sort(
+    std::begin(bricks), 
+    std::end(bricks), 
+    [](const auto& b1, const auto& b2) { 
+      return b1.start[2] < b2.start[2];
+    }
+  );
+  {  
+    const auto h = bricks[0].end[2] - bricks[0].start[2];
+    bricks[0].start[2] = 1;
+    bricks[0].end[2] = 1 + h;
+  }
+  for (int i = 1; i < bricks.size(); i++) {
+    // std::cout << "\nBrick moving down: " << char('A' + bricks[i].id) << '\n';
+    const auto h = bricks[i].end[2] - bricks[i].start[2];
+    for (int j = i - 1; j >= 0; j--) {
+    // std::cout << "Comparing with: " << char('A' + bricks[j].id) << '\n';
+      bricks[i].start[2] = bricks[j].start[2];
+      bricks[i].end[2] = bricks[i].start[2] + h;
+      if (check_if_overlap(bricks[i], bricks[j])) {
+        // std::cout << "Overlap found between " << char('A' + bricks[i].id) << " and " << char('A' + bricks[j].id) << '\n';
+        // std::cout << char('A' + bricks[j].id) << " occupies " << bricks[j].start[2] << "->" <<  bricks[j].end[2]  << " in Z" << '\n';
+        bricks[i].start[2] = bricks[j].end[2] + 1;
+        bricks[i].end[2] = bricks[i].start[2] + h;
+        // std::cout << char('A' + bricks[i].id) << " now set to " << bricks[i].start[2] << "->" <<  bricks[i].end[2]  << '\n';
+        break;
+      }
+    }
+    std::partial_sort(
+      std::begin(bricks), 
+      std::next(std::begin(bricks), i), 
+      std::end(bricks), 
+      [](const auto& b1, const auto& b2) { 
+        return b1.end[2] < b2.end[2];
+      }
+    );
+  }
+  std::array<int, 3> values {0,0,0};
+  for (const auto& b : bricks) {
+    values[0] = std::max(values[0], b.start[0]);
+    values[0] = std::max(values[0], b.end[0]);
+    values[1] = std::max(values[1], b.start[1]);
+    values[1] = std::max(values[1], b.end[1]);
+    values[2] = std::max(values[2], b.start[2]);
+    values[2] = std::max(values[2], b.end[2]);
+  }
+  std::vector<std::vector<std::vector<int>>> map (
+    values[0]+1, std::vector<std::vector<int>>(
+      values[1]+1, std::vector<int>(
+        values[2]+1, 0
+      )
+    )
+  );
+  // std::cout << values[0] << ' ' << values[1] << ' ' << values[2] << '\n';
+  for (const auto& b : bricks) {
+    for (int x = std::min(b.start[0],b.end[0]); x <= std::max(b.start[0],b.end[0]); x++) {
+      for (int y = std::min(b.start[1], b.end[1]); y <= std::max(b.start[1],b.end[1]); y++) {
+        for (int z = std::min(b.start[2], b.end[2]); z <= std::max(b.start[2],b.end[2]); z++) {
+          // std::cout << x << ' ' << y << ' ' << z << '\n';
+          map[x][y][z] = b.id;
+        }
+      }
+    }
+  }
+  
+  // for (int z = 0; z <= values[2]; z++) {
+  //   for (int x = 0; x <= values[0]; x++) {
+  //     std::cout << map[x][0][z];
+  //   }
+  //   std::cout << '\n';
+  // }
+  
+  std::unordered_map<int, std::vector<int>> supports;
+  std::unordered_map<int, std::vector<int>> supported_by;
+  for(const auto& b : bricks) {
+    supports[b.id] = {};
+    supported_by[b.id] = {};
+  }
+  for (int i = 0; i < bricks.size(); i++) {
+    for (int j = 0; j < bricks.size(); j++) {
+      if (i == j) continue;
+      if(bricks[i].end[2] + 1 == bricks[j].start[2] && check_if_overlap(bricks[i], bricks[j])) {
+        supports[bricks[i].id].push_back(bricks[j].id);
+        supported_by[bricks[j].id].push_back(bricks[i].id);
+      }
+    }
+  }
+  int count = 0;
+  for (const auto& [current, supported_by_current] : supports) {
+    bool can_be_disintegrated = true;
+    for (const auto& ele : supported_by_current) {
+      if (supported_by[ele].size() == 1) {
+        can_be_disintegrated = false;
+        break;
+      }
+    }
+    if (can_be_disintegrated) {
+      count++;
+    }
+  }
+  std::cout << count << '\n';
+  return 0;
+}

2023/cpp/day_22b.cpp

@@ -0,0 +1,194 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <stack>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <regex>
+#include <cassert>
+
+
+struct Brick {
+  std::array<int, 3> start {0,0,0};
+  std::array<int, 3> end {0,0,0};
+  int id = 0;
+  bool operator == (const Brick& b) const {
+    return b.start == start && b.end == end;
+  }
+};
+
+bool check_if_overlap(const Brick& b1, const Brick& b2) {
+  bool x_overlap = false;
+  bool y_overlap = false;
+  x_overlap = std::min(b2.start[0], b2.end[0]) <= b1.start[0] && b1.start[0] <= std::max(b2.start[0], b2.end[0]);
+  y_overlap = std::min(b2.start[1], b2.end[1]) <= b1.start[1] && b1.start[1] <= std::max(b2.start[1], b2.end[1]);
+  if (x_overlap && y_overlap) return true;
+  x_overlap = x_overlap || std::min(b2.start[0], b2.end[0]) <= b1.end[0] && b1.end[0] <= std::max(b2.start[0], b2.end[0]);
+  y_overlap = y_overlap || std::min(b2.start[1], b2.end[1]) <= b1.end[1] && b1.end[1] <= std::max(b2.start[1], b2.end[1]);
+  if (x_overlap && y_overlap) return true;
+  x_overlap = x_overlap || std::min(b1.start[0], b1.end[0]) <= b2.start[0] && b2.start[0] <= std::max(b1.start[0], b1.end[0]);
+  y_overlap = y_overlap || std::min(b1.start[1], b1.end[1]) <= b2.start[1] && b2.start[1] <= std::max(b1.start[1], b1.end[1]);
+  if (x_overlap && y_overlap) return true;
+  x_overlap = x_overlap || std::min(b1.start[0], b1.end[0]) <= b2.end[0] && b2.end[0] <= std::max(b1.start[0], b1.end[0]);
+  y_overlap = y_overlap || std::min(b1.start[1], b1.end[1]) <= b2.end[1] && b2.end[1] <= std::max(b1.start[1], b1.end[1]);
+  if (x_overlap && y_overlap) return true;
+  return false;
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_22_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  const std::regex mask_pattern(R"((-?[0-9]+),(-?[0-9]+),(-?[0-9]+)~(-?[0-9]+),(-?[0-9]+),(-?[0-9]+))");
+  std::smatch mask_match;
+  std::vector<Brick> bricks;
+  while(std::getline(file, line)) {
+    std::regex_search(line, mask_match, mask_pattern); 
+    Brick b;
+    b.id = bricks.size();
+    b.start[0] = std::stoi(mask_match[1]);
+    b.start[1] = std::stoi(mask_match[2]);
+    b.start[2] = std::stoi(mask_match[3]);
+    b.end[0] = std::stoi(mask_match[4]);
+    b.end[1] = std::stoi(mask_match[5]);
+    b.end[2] = std::stoi(mask_match[6]);
+    bricks.push_back(b);
+    // std::cout << b.start[0] << ' ' << b.start[1] << ' ' 
+    //           << b.start[2] << ' ' << b.end[0] << ' ' 
+    //           << b.end[1]<< ' ' << b.end[2] << '\n';
+  }
+  for (auto& b : bricks) {
+    if (b.start[2] > b.end[2]) {
+      std::swap(b.start, b.end);
+    }
+  }
+  std::sort(
+    std::begin(bricks), 
+    std::end(bricks), 
+    [](const auto& b1, const auto& b2) { 
+      return b1.start[2] < b2.start[2];
+    }
+  );
+  {  
+    const auto h = bricks[0].end[2] - bricks[0].start[2];
+    bricks[0].start[2] = 1;
+    bricks[0].end[2] = 1 + h;
+  }
+  for (int i = 1; i < bricks.size(); i++) {
+    // std::cout << "\nBrick moving down: " << char('A' + bricks[i].id) << '\n';
+    const auto h = bricks[i].end[2] - bricks[i].start[2];
+    for (int j = i - 1; j >= 0; j--) {
+    // std::cout << "Comparing with: " << char('A' + bricks[j].id) << '\n';
+      bricks[i].start[2] = bricks[j].start[2];
+      bricks[i].end[2] = bricks[i].start[2] + h;
+      if (check_if_overlap(bricks[i], bricks[j])) {
+        // std::cout << "Overlap found between " << char('A' + bricks[i].id) << " and " << char('A' + bricks[j].id) << '\n';
+        // std::cout << char('A' + bricks[j].id) << " occupies " << bricks[j].start[2] << "->" <<  bricks[j].end[2]  << " in Z" << '\n';
+        bricks[i].start[2] = bricks[j].end[2] + 1;
+        bricks[i].end[2] = bricks[i].start[2] + h;
+        // std::cout << char('A' + bricks[i].id) << " now set to " << bricks[i].start[2] << "->" <<  bricks[i].end[2]  << '\n';
+        break;
+      }
+    }
+    // While the bricks are arranged in z bfore they start falling, 
+    // they might have a differnt height order after they land
+    std::partial_sort(
+      std::begin(bricks), 
+      std::next(std::begin(bricks), i), 
+      std::end(bricks), 
+      [](const auto& b1, const auto& b2) { 
+        return b1.end[2] < b2.end[2];
+      }
+    );
+  }
+  std::array<int, 3> values {0,0,0};
+  for (const auto& b : bricks) {
+    values[0] = std::max(values[0], b.start[0]);
+    values[0] = std::max(values[0], b.end[0]);
+    values[1] = std::max(values[1], b.start[1]);
+    values[1] = std::max(values[1], b.end[1]);
+    values[2] = std::max(values[2], b.start[2]);
+    values[2] = std::max(values[2], b.end[2]);
+  }
+  std::vector<std::vector<std::vector<int>>> map (
+    values[0]+1, std::vector<std::vector<int>>(
+      values[1]+1, std::vector<int>(
+        values[2]+1, 0
+      )
+    )
+  );
+  // std::cout << values[0] << ' ' << values[1] << ' ' << values[2] << '\n';
+  for (const auto& b : bricks) {
+    for (int x = std::min(b.start[0],b.end[0]); x <= std::max(b.start[0],b.end[0]); x++) {
+      for (int y = std::min(b.start[1], b.end[1]); y <= std::max(b.start[1],b.end[1]); y++) {
+        for (int z = std::min(b.start[2], b.end[2]); z <= std::max(b.start[2],b.end[2]); z++) {
+          // std::cout << x << ' ' << y << ' ' << z << '\n';
+          map[x][y][z] = b.id;
+        }
+      }
+    }
+  }
+  
+  // for (int z = 0; z <= values[2]; z++) {
+  //   for (int x = 0; x <= values[0]; x++) {
+  //     std::cout << map[x][0][z];
+  //   }
+  //   std::cout << '\n';
+  // }
+  
+  std::unordered_map<int, std::vector<int>> supports;
+  std::unordered_map<int, std::vector<int>> supported_by;
+  for(const auto& b : bricks) {
+    supports[b.id] = {};
+    supported_by[b.id] = {};
+  }
+  for (int i = 0; i < bricks.size(); i++) {
+    for (int j = 0; j < bricks.size(); j++) {
+      if (i == j) continue;
+      if(bricks[i].end[2] + 1 == bricks[j].start[2] && check_if_overlap(bricks[i], bricks[j])) {
+        supports[bricks[i].id].push_back(bricks[j].id);
+        supported_by[bricks[j].id].push_back(bricks[i].id);
+      }
+    }
+  }
+  std::size_t count = 0;
+  for (const auto& b : bricks) {
+    std::queue<int> q;
+    for (const auto& ele : supports[b.id]) {
+      q.push(ele);
+    }
+    // Do not cache bricks that might have been seen as 
+    // they are added each time one of the bricks that supports them is destroyed
+    // Only the last time they are added, 
+    // at which point all the bricks supporting them might have been destroyed
+    // will they be free fall and hence be counted
+    std::unordered_set<int> moved {b.id};
+    while(!q.empty()) {
+      const auto current = q.front();
+      q.pop();
+      bool will_move = true;
+      for (const auto& ele : supported_by[current]) {
+        if (moved.find(ele) == moved.end()) {
+          will_move = false;
+          break;
+        }
+      }
+      if (!will_move) continue;
+      moved.insert(current);
+      for (const auto& supported_by_current : supports[current]) {
+        q.push(supported_by_current);
+      }
+    }
+    count += moved.size() - 1;
+  }
+  std::cout << count << '\n';
+  return 0;
+}

2023/cpp/day_23a.cpp

@@ -0,0 +1,133 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <stack>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+struct Point {
+  int row;
+  int col;
+
+  Point(const int row = 0, const int col = 0) : row(row), col(col) {}
+
+  Point operator + (const Point& p) const {
+    return Point (p.row + row,  p.col + col);
+  }
+
+  bool operator == (const Point& p) const {
+    return p.row == row && p.col == col;
+  }
+};
+
+struct hasher {
+  std::size_t operator() (const Point& p) const {
+    return p.row + p.col;
+  }
+};
+
+const std::vector<Point> motions ={
+  Point(-1,0),
+  Point(0,1),
+  Point(1,0),
+  Point(0, -1),
+};
+
+bool in_limits(const std::vector<std::string>& map, const int row, const int col) {
+  return row >= 0 && row < map.size() && col >= 0 && col < map[0].size();
+}
+
+void dfs(std::stack<Point>& stack, const std::vector<std::string>& map, int steps, int& max_steps, const Point& dest, std::vector<std::vector<bool>>& seen) {
+  if (!stack.empty()) {
+    const Point current = stack.top();
+    seen[current.row][current.col] = true;
+    if (current == dest) {
+      max_steps = std::max(steps, max_steps);
+      seen[current.row][current.col] = false;
+      return;
+    }
+    if (map[current.row][current.col] != '.') {
+      Point next;
+      if (map[current.row][current.col] == '^') {
+        next.row = current.row - 1;
+        next.col = current.col;
+      }
+      else if (map[current.row][current.col] == '>') {
+        next.row = current.row;
+        next.col = current.col + 1;
+      }
+      else if (map[current.row][current.col] == 'v') {
+        next.row = current.row + 1;
+        next.col = current.col;
+      }
+      else if (map[current.row][current.col] == '<') {
+        next.row = current.row;
+        next.col = current.col - 1;
+      } 
+      else {
+        std::cout << "this should not happen" << '\n';
+      }
+      if(in_limits(map, next.row, next.col) && map[next.row][next.col] != '#' && !seen[next.row][next.col]) {
+        stack.push(next);
+        dfs(stack, map, steps + 1, max_steps, dest, seen);
+        stack.pop();
+      }
+    } else {
+      for (const auto& motion : motions) {
+        const auto next = current + motion;
+        if(in_limits(map, next.row, next.col) && map[next.row][next.col] != '#' && !seen[next.row][next.col]) {
+          stack.push(next);
+          dfs(stack, map, steps + 1, max_steps, dest, seen);
+          stack.pop();
+        } 
+      }
+    }
+    seen[current.row][current.col] = false;
+  }
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_24_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::vector<std::string> map;
+  while(std::getline(file, line)) {
+    map.emplace_back(line);
+  }
+
+  // std::priority_queue<Point, std::vector<Point>, Comparator> pq;
+  std::stack<Point> stack;
+  std::vector<std::vector<bool>> seen(map.size(), std::vector<bool>(map[0].size(), false));
+  
+  Point current;
+  current.row = 0;
+  for (int col = 0; col < map[0].size(); col++) {
+    if (map[0][col] == '.') {
+      current.col = col;
+      break;
+    }
+  }
+
+  Point dest;
+  dest.row = map.size() - 1;
+  for (int col = 0; col < map[dest.row].size(); col++) {
+    if (map[dest.row][col] == '.') {
+      dest.col = col;
+      break;
+    }
+  }
+
+  stack.push(current);
+  int max_steps = 0;
+  dfs(stack, map, 0, max_steps, dest, seen);
+  std::cout << max_steps << '\n';
+  return 0;
+}

2023/cpp/day_23b.cpp

@@ -0,0 +1,184 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <queue> 
+#include <stack>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+// IDEA:
+// Convert the maze to a graph where 
+// nodes in the graph are points with more than 2 adjacent points that are not forests  
+// edges in the graph connect 2 nodes (no nodes in the middle of an edge)
+// Run dfs on the graph
+
+struct Point {
+  int row;
+  int col;
+  std::size_t dist = 0;
+
+  Point(const int row = 0, const int col = 0) : row(row), col(col) {}
+
+  Point operator + (const Point& p) const {
+    return Point (p.row + row,  p.col + col);
+  }
+
+  bool operator == (const Point& p) const {
+    return p.row == row && p.col == col;
+  }
+};
+
+struct Edge {
+  Point start;
+  Point end;
+  std::size_t dist;
+};
+
+struct hasher_point {
+  std::size_t operator() (const Point& p) const {
+    return p.row + p.col;
+  }
+};
+
+
+const std::vector<Point> motions ={
+  Point(-1,0),
+  Point(0,1),
+  Point(1,0),
+  Point(0, -1),
+};
+
+bool in_limits(const std::vector<std::string>& map, const int row, const int col) {
+  return row >= 0 && row < map.size() && col >= 0 && col < map[0].size();
+}
+
+void dfs(std::stack<Point>& stack,  
+         std::unordered_map<Point, std::vector<Edge>, hasher_point>& node_to_edges_map, 
+         std::size_t& max_dist, 
+         const Point& dest, 
+         std::vector<std::vector<bool>>& seen) {
+  if (!stack.empty()) {
+    const Point current = stack.top();
+    seen[current.row][current.col] = true;
+    if (current == dest) {
+      max_dist = std::max(current.dist, max_dist);
+      seen[current.row][current.col] = false;
+    } else{
+      for (const auto& edge : node_to_edges_map[current]) {
+        auto next = edge.end;
+        next.dist = current.dist + edge.dist;
+        if(!seen[next.row][next.col]) {
+          stack.push(next);
+          dfs(stack, node_to_edges_map, max_dist, dest, seen);
+          stack.pop();
+        }
+      }
+    }
+    seen[current.row][current.col] = false;
+  }
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_23_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::vector<std::string> map;
+  while(std::getline(file, line)) {
+    map.emplace_back(line);
+  }
+
+  Point start;
+  start.row = 0;
+  for (int col = 0; col < map[0].size(); col++) {
+    if (map[0][col] == '.') {
+      start.col = col;
+      break;
+    }
+  }
+
+  Point dest;
+  dest.row = map.size() - 1;
+  for (int col = 0; col < map[dest.row].size(); col++) {
+    if (map[dest.row][col] == '.') {
+      dest.col = col;
+      break;
+    }
+  }
+  
+  // IDEA:
+  // Convert the maze to a graph where 
+  // nodes in the graph are points with more than 2 adjacent points that are not forests  
+  // edges in the graph connect 2 nodes (no nodes in the middle of an edge)
+  // Run dfs on the graph
+  
+  // Find nodes
+  std::stack<Point> stack;
+  std::vector<std::vector<bool>> seen(map.size(), std::vector<bool>(map[0].size(), false));
+  std::unordered_set<Point, hasher_point> nodes{start, dest}; // Assumes start and end have only 1 open adjacent point
+  stack.push(start);
+  while (!stack.empty()) {
+    const Point current = stack.top();
+    stack.pop();
+    seen[current.row][current.col] = true;
+    int count = 0;
+    for (const auto& motion : motions) {
+      const auto next = current + motion;
+      if(in_limits(map, next.row, next.col) && map[next.row][next.col] != '#') {
+        // std::cout << "Considering: " << next.row << ',' << next.col << '\n';
+        count++;
+        if(!seen[next.row][next.col]) stack.push(next);
+      } 
+    }
+    if (count > 2) {
+      nodes.insert(current);
+      // std::cout << "NODE: " << current.row << ',' << current.col << '\n';
+    }
+  }
+
+  // Find the length of each edge in the graph where an edge connects 2 nodes
+  // There are no nodes in the middle of an edge
+  std::unordered_map<Point, std::vector<Edge>, hasher_point> node_to_edges_map;
+  for (const auto& node : nodes) {
+    seen = std::vector<std::vector<bool>> (map.size(), std::vector<bool>(map[0].size(), false));
+    while(!stack.empty()) stack.pop();
+    stack.push(node);
+    while (!stack.empty()) {
+      const Point current = stack.top();
+      stack.pop();
+      seen[current.row][current.col] = true;
+      for (const auto& motion : motions) {
+        auto next = current + motion;
+        next.dist = current.dist + 1;
+        if(in_limits(map, next.row, next.col) && map[next.row][next.col] != '#' && !seen[next.row][next.col]) {
+          if (nodes.find(next) == nodes.end()) {
+            stack.push(next);
+          } else{
+            Edge e;
+            e.start = node;
+            e.end = next;
+            e.dist = next.dist;
+            node_to_edges_map[node].push_back(e);
+            e.start = next;
+            e.end = node;
+            node_to_edges_map[node].push_back(e);
+          }
+        } 
+      }
+    }
+  }
+
+  // Run DFS on the nodes using the precalculated edge distances
+  seen = std::vector<std::vector<bool>> (map.size(), std::vector<bool>(map[0].size(), false));
+  stack.push(start);
+  std::size_t max_dist = 0;
+  dfs(stack, node_to_edges_map, max_dist, dest, seen);
+  std::cout << max_dist << '\n';
+  return 0;
+}

2023/cpp/day_24a.cpp

@@ -0,0 +1,114 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <limits>
+#include <queue>
+#include <regex> 
+#include <stack>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cassert> 
+
+// constexpr double limit_min = 7;
+// constexpr double limit_max = 27;
+
+constexpr double limit_min = 200000000000000;
+constexpr double limit_max = 400000000000000;
+
+struct Line {
+  // ax + by = c
+  double a;
+  double b;
+  double c;
+};
+
+struct Hailstone {
+  std::array<double, 3> position;
+  std::array<double, 3> velocity; 
+};
+
+Hailstone parse_input(const std::string& line) {
+  const std::regex pattern(R"((-?[0-9]+),(-?[0-9]+),(-?[0-9]+)@(-?[0-9]+),(-?[0-9]+),(-?[0-9]+))");
+  std::smatch match;
+  std::regex_search(line, match, pattern); 
+  // std::cout << '|' << line << '|' << '\n';
+  // std::cout << match[0] << '\n';
+  Hailstone hs;
+  hs.position[0] = std::stod(match[1]);
+  hs.position[1] = std::stod(match[2]);
+  hs.position[2] = std::stod(match[3]);
+  hs.velocity[0] = std::stod(match[4]);
+  hs.velocity[1] = std::stod(match[5]);
+  hs.velocity[2] = std::stod(match[6]);
+  return hs;
+}
+
+Line calculate_trajectory(const Hailstone& hs) {
+  Line line;
+  if (hs.velocity[0] == 0) {
+    line.a = 0;
+    line.b = 1;
+    line.c = hs.position[0];
+  } else {
+    line.a = -hs.velocity[1];
+    line.b = hs.velocity[0];
+    line.c = line.b * hs.position[1] + line.a * hs.position[0];
+    // line.is_vertical = false;
+    // std::cout << -line.a/line.b << ' ' << hs.velocity[1]/hs.velocity[0] << '\n';
+    assert(-line.a/line.b == hs.velocity[1]/hs.velocity[0]);
+    // std::cout << line.a << " x + " << line.b << " y  = " << line.c << '\n';
+
+    // std::cout << hs.position[1] << ' ' << line.m * hs.position[0] + line.c << ' ' << std::fabs(hs.position[1] - line.m * hs.position[0] - line.c) << '\n';
+    // assert(std::fabs(hs.position[1] - line.m * hs.position[0] - line.c) < 0.00001);
+  }
+  return line;
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_24_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::vector<Hailstone> hailstones;
+  std::vector<Line> trajectories;
+  while(std::getline(file, line)) {
+    line.erase(std::remove_if(line.begin(), line.end(), [](const char c) {return c == ' ';}), line.end());
+    hailstones.emplace_back(parse_input(line));
+    trajectories.emplace_back(calculate_trajectory(hailstones.back()));
+  }
+
+  int n_intersections = 0;
+  for (int i = 0; i < trajectories.size(); i++) {
+    const auto& line_1 = trajectories[i];
+    for (int j = i+1; j < trajectories.size(); j++) {
+      const auto& line_2 = trajectories[j];
+      const auto determinant = (line_1.a * line_2.b) - (line_2.a * line_1.b);
+      // std::cout << "\nStart: " << '(' << i << "," << j << ')' << '\n';
+      // std::cout << determinant << '\n';
+      if (determinant == 0) continue;
+      const auto x = ((line_1.c * line_2.b) - (line_2.c * line_1.b)) / determinant;
+      const auto y = ((line_1.a * line_2.c) - (line_2.a * line_1.c)) / determinant;
+      if ((x - hailstones[i].position[0])/hailstones[i].velocity[0] < 0 ) {
+        // std::cout << "intersected in the past" << '\n';
+        continue;
+      }
+      if ((x - hailstones[j].position[0])/hailstones[j].velocity[0] < 0 ) {
+        // std::cout << "intersected in the past" << '\n';
+        continue;
+      }
+      // std::cout << x << ' ' << y  << '\n';
+      if (x >= limit_min && x <= limit_max && y >= limit_min && y <= limit_max) {
+        // std::cout << "Incrementing" << '\n';
+        n_intersections++;
+      }
+    }
+  }
+  std::cout << n_intersections << '\n';
+  return 0;
+}

2023/cpp/day_24b.cpp

@@ -0,0 +1,256 @@
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <limits>
+#include <queue>
+#include <regex> 
+#include <stack>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cassert> 
+
+// Let (x0, y0, z0) and (vx0, vy0, vz0) be the position from and velocity with which the rock must be thrown
+// Let (xi, yi, zi) and (vxi, vyi, vzi) be the position and velocity of the ith hailstone, where i ranges from 1 to some `n`
+// hence there exists a time ti for every hailstone where the hailstone and the rock are at exactly the same position
+// hence 
+// x0 + vx0 * ti = xi + vxi * ti ... (1)
+// => (x0 - xi) = - (vx0 - vxi) * ti 
+// => (x0 - xi) / (vx0 - vxi) = -ti ... (2) (Assuming vx0 != vxi)
+// Similarly
+// (y0 - yi) / (vy0 - vyi) = - ti ... (3)
+// (z0 - zi) / (vz0 - vzi) = - ti ... (4)
+// Since the LHSs of (2) and (3) are both ti
+// (x0 - xi) / (vx0 - vxi) = (y0 - yi) /  (vy0 - vyi)
+// (x0 - xi) * (vy0 - vyi) = (y0 - yi) * (vx0 - vxi) 
+// x0 * vy0 - xi * vy0 - x0 * vyi + xi * vyi = y0 * vx0 - yi * vx0 - y0 * vxi + yi * vxi
+// This hold true for any i
+// Let i = 1: x0 * vy0 - x1 * vy0 - x0 * vy1 + x1 * vy1 = y0 * vx0 - y1 * vx0 - y0 * vx1 + y1 * vx1 ... (5)
+// Let i = 2: x0 * vy0 - x2 * vy0 - x0 * vy2 + x2 * vy2 = y0 * vx0 - y2 * vx0 - y0 * vx2 + y2 * vx2 ... (6)
+// Subtract (6) from (5):
+// (-x1 + x2) * vy0 + (-vy1 + vy2) * x0 + (x1 * vy1) - (x2 * vy2)
+//                   = (-y1 + y2) * vx0 + (-vx1 + vx2) * y0 +( y1 * vx1) + (y2 * vx2)
+// Rearranging the terms:
+// (-vy1 + vy2) * x0 - (-vx1 + vx2) * y0 - (-y1 + y2) * vx0 + (-x1 + x2) * vy0 
+//                   = -(x1 * vy1) + (x2 * vy2) +( y1 * vx1) + (y2 * vx2)
+// Where all the coefficients of the position and velocities of the hailstones 1 and 2 are known, so this becomes
+// c1 * x0 + c2 * y0 + c3 * vx0 + c4 * vy0 = c5 where ci is some known constant ... (7)
+// Also, while (7) was obtained using ((1) and (2)), observe that this sort of an equation can be reached even by using ((2) and (4)) or ((3) and (4))
+// c6 * y0 + c7 * z0 + c8 * vy0 + c9 * vz0 = c10 where ci is some known constant
+// c11 * y0 + c12 * z0 + c13 * vy0 + c14 * vz0 = c15 where ci is some known constant
+// Also note that while here hailstones 1 and 2 were chosen, this can be done for any pair of hailstones
+// In (7) there are 4 unknowns, so by taking 4 pairs of hailstones, 4 equations can be obtained
+// These can then be put in a matrix:
+// [Some     ][x0 ] =  [Some other]
+// [matrix   ][y0 ]    [matrix    ]
+// [of       ][vx0]    [of        ]
+// [constants][vy0]    [constants ]
+// Multiplying both sides by the inverse of first matrix gives
+// [x0 ] = Inverse([Some     ]) * [Some other]
+// [y0 ] =         [matrix   ]    [matrix    ]
+// [vx0] =         [of       ]    [of        ]
+// [vy0] =         [constants]    [constants ]
+// This provides 4 out of th e6 unknowns
+// For the other 2 the same process is repeated, but with 2 equations this time with y and z instead of x and y
+// Only 2 equations are needed since the values of y have already been calculated, 
+// but the values of y can be recalculated using 4 equations to sanity check the solution
+// This provides all the unknowns and hence the answer
+
+struct Hailstone {
+  std::array<long double, 3> position;
+  std::array<long double, 3> velocity; 
+};
+
+Hailstone parse_input(const std::string& line) {
+  const std::regex pattern(R"((-?[0-9]+),(-?[0-9]+),(-?[0-9]+)@(-?[0-9]+),(-?[0-9]+),(-?[0-9]+))");
+  std::smatch match;
+  std::regex_search(line, match, pattern); 
+  Hailstone hs;
+  hs.position[0] = std::stod(match[1]);
+  hs.position[1] = std::stod(match[2]);
+  hs.position[2] = std::stod(match[3]);
+  hs.velocity[0] = std::stod(match[4]);
+  hs.velocity[1] = std::stod(match[5]);
+  hs.velocity[2] = std::stod(match[6]);
+  return hs;
+}
+
+template<size_t N>
+constexpr std::array<std::array<long double, N>, N> inverse_using_LU_decomp(std::array<std::array<long double, N>, N> mat) {
+  std::array<std::array<long double, N>, N> p;
+  std::array<std::array<long double, N>, N> inversed_data;
+  for (int i = 0; i < N; i++) {
+    for (int j = 0; j < N; j++) {
+      if (i == j) p[i][j] = 1;
+      else p[i][j] = 0;
+    }
+  }
+  for (int i = 0; i < N - 1; i++){
+    auto max_idx = i;
+    for (int k  = i+1; k < N; k++) {
+      if (std::abs(mat[k][i]) > std::abs(mat[max_idx][i])) {
+        max_idx = k;
+      }
+    }
+
+    std::swap(mat[i], mat[max_idx]);
+    std::swap(p[i], p[max_idx]);
+
+    for (int j = i+1; j < N; j++) {
+      mat[j][i] /= mat[i][i];
+      for (int k = i+1; k < N; k++) {
+        mat[j][k] -= mat[j][i] * mat[i][k];
+      }
+    }
+  }
+
+  for (int i_main = 0; i_main < N; i_main++) {
+    std::array<long double, N> b;
+    for (int j = 0; j < N; j++) {
+      if (i_main == j) {
+        b[j] = 1;
+      } else {
+        b[j] = 0;
+      }
+    }
+
+    auto temp = b;
+    for (int i = 0; i < N; i++) {
+      temp[i] = std::inner_product(std::begin(p[i]), std::end(p[i]), std::begin(b), 0.);
+    }
+    b = temp;
+
+    for (int i = 0; i < N-1; i++){
+      for (int j = i+1; j < N; j++)  {
+        b[j] -= mat[j][i] * b[i];
+      }
+    }
+
+    for (int i = N-1; i >=0; i--) {
+      b[i] /= mat[i][i];
+      for (int j = 0; j < i; j++) {
+        b[j] -= mat[j][i] * b[i];
+      }
+    }
+
+    for (int k =0; k < N; k++) {
+      inversed_data[k][i_main] = b[k];
+    }
+  }
+  return inversed_data;
+}
+
+// The function get_equation below provides the cofficients of equation 7 
+// With the returned array containing c1, c2, c3, c4 and the returned double containing c5
+// idx0 and idx1 help choose whether the function uses the coefficients of 
+// (x,y) or (y,z) or (x,z) by using the values
+// (0,1) or (1,2) or (0,2)
+std::tuple<bool, std::array<long double, 4>, long double> get_equation(const Hailstone& hs1, const Hailstone& hs2, const int idx0, const int idx1) {
+  if (hs1.position[idx1] == hs2.position[idx1]) return {false, std::array<long double, 4>(), 0};
+  if (hs1.velocity[idx1] == hs2.velocity[idx1]) return {false, std::array<long double, 4>(), 0};
+  const std::tuple<bool, std::array<long double, 4>, long double> ans = {
+    true,
+    {
+      (hs2.velocity[idx1] - hs1.velocity[idx1]), // coeffecient of x0 if idx0 = 0
+      -(hs2.velocity[idx0] - hs1.velocity[idx0]), // coeffecient of y0 if idx1 = 1
+      -(hs2.position[idx1] - hs1.position[idx1]), // coeffecient of vx0 if idx0 = 0
+      (hs2.position[idx0] - hs1.position[idx0]) // coeffecient of vy0 if idx1 = 1
+    },
+    ((hs1.position[idx1] * hs1.velocity[idx0]) - (hs1.position[idx0] * hs1.velocity[idx1]))
+    - ((hs2.position[idx1] * hs2.velocity[idx0]) - (hs2.position[idx0] * hs2.velocity[idx1])) // RHS
+  };
+  // std::cout << std::get<1>(ans)[0] << ' ' 
+  //           << std::get<1>(ans)[1] << ' ' 
+  //           << std::get<1>(ans)[2] << ' ' 
+  //           << std::get<1>(ans)[3] << " | " 
+  //           << std::get<2>(ans) << '\n';
+  return ans;
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_24_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::vector<Hailstone> hailstones;
+  while(std::getline(file, line)) {
+    line.erase(std::remove_if(line.begin(), line.end(), [](const char c) {return c == ' ';}), line.end());
+    hailstones.emplace_back(parse_input(line));
+  }
+  std::array<long double, 3> ans_position;
+  std::array<long double, 3> ans_velocity;
+  // Calculating for (x,y)
+  {
+    int count = 0;
+    std::array<std::array<long double, 4>, 4> main_lhs;
+    std::array<long double, 4> main_rhs;
+    for(int i = 0; i < hailstones.size()-1 && count < 4; i++) {
+      for(int j = i+1; j < hailstones.size() && count < 4; j++) {
+        const auto [valid, lhs, rhs] = get_equation(hailstones[i], hailstones[j], 0, 1);
+        if (valid) {
+          main_lhs[count] = lhs;
+          main_rhs[count] = rhs;
+          count++;
+        }
+      }
+    }
+    const auto inverse = inverse_using_LU_decomp<4>(main_lhs);
+    std::array<long double, 4> answer_of_calcs {0,0,0,0};
+    for (int row = 0; row < 4; row++) {
+      for (int col = 0; col < 4; col++) {
+        answer_of_calcs[row] += inverse[row][col] * main_rhs[col]; 
+      }
+    }
+    ans_position[0] = answer_of_calcs[0];
+    ans_position[1] = answer_of_calcs[1];
+    ans_velocity[0] = answer_of_calcs[2];
+    ans_velocity[1] = answer_of_calcs[3];
+  }
+  // Calculating for (x,z)
+  {
+    int count = 0;
+    std::array<std::array<long double, 4>, 4> main_lhs;
+    std::array<long double, 4> main_rhs;
+    for(int i = 0; i < hailstones.size()-1 && count < 4; i++) {
+      for(int j = i+1; j < hailstones.size() && count < 4; j++) {
+        const auto [valid, lhs, rhs] = get_equation(hailstones[i], hailstones[j], 1, 2);
+        if (valid) {
+          main_lhs[count] = lhs;
+          main_rhs[count] = rhs;
+          count++;
+        }
+      }
+    }
+    const auto inverse = inverse_using_LU_decomp<4>(main_lhs);
+    std::array<long double, 4> answer_of_calcs {0,0,0,0};
+    for (int row = 0; row < 4; row++) {
+      for (int col = 0; col < 4; col++) {
+        answer_of_calcs[row] += inverse[row][col] * main_rhs[col]; 
+      }
+    }
+    // assert(ans_position[0] == answer_of_calcs[0]);
+    // assert(ans_position[2] == answer_of_calcs[2]);
+    ans_position[2] = answer_of_calcs[1];
+    ans_velocity[2] = answer_of_calcs[3];
+  }
+  // std::cout << "Answers: " << '\n';
+  // for (const auto& ele : ans_position) {
+  //   std::cout << std::fixed << ele << ' ';
+  // } 
+  // std::cout << '\n';
+  // for (const auto& ele : ans_velocity) {
+  //   std::cout << std::fixed << ele << ' ';
+  // } 
+  // std::cout << '\n';
+  long long answer = 0;
+  for (const auto& ele : ans_position) {
+    answer += static_cast<long long>(ele);
+  }
+  std::cout << std::fixed << answer << '\n';
+  return 0;
+}

2023/cpp/day_25a.cpp

@@ -0,0 +1,186 @@
+#include <algorithm>
+#include <numeric>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <unordered_set>  
+#include <unordered_map>  
+#include <random>
+#include <cassert>
+#include <stack>
+
+// Used Karger's algorithm
+// Refactor this; should run much faster
+// Also, other algos are available
+
+struct Edge {
+  std::string start;
+  std::string end;
+  std::size_t hash = 0;
+  bool operator == (const Edge& e) const{
+    return start == e.start && end == e.end;
+  }
+  void update_hash() {
+    std::size_t p = 1;
+    for (int i = 0; i < start.size(); i++) {
+      hash += p * (start[i] - 'a');
+      p*= 10;
+    }
+    for (int i = 0; i < end.size(); i++) {
+      hash += p * (start[i] - 'a');
+      p *= 10;
+    }
+  }
+};
+
+struct hasher {
+  std::size_t operator () (const Edge& e) const {
+    return e.hash;
+
+  }
+};
+
+void parse_input(const std::string& input_str, std::unordered_set<Edge, hasher>& edges) {
+  const std::string from = input_str.substr(0, 3);
+  std::size_t start = 5;
+  std::size_t end = input_str.find(' ', start);
+  while (end != std::string::npos) {
+    const std::string to = input_str.substr(start, end - start);
+    start = end + 1;
+    end = input_str.find(' ', start);
+    Edge edge;
+    edge.start = from;
+    edge.end = to;
+    edge.update_hash();
+    edges.insert(edge);
+  }
+  const std::string to = input_str.substr(start, input_str.size() - start);
+  Edge edge;
+  edge.start = from;
+  edge.end = to;
+  edges.insert(edge);
+}
+
+const std::string& UnionFindRCFindUtil(const std::string& v, std::unordered_map<std::string, std::pair<std::string, int>>& subsets){
+  if(v != subsets[v].first) {
+    subsets[v].first = UnionFindRCFindUtil(subsets[v].first, subsets);
+  }
+  return subsets[v].first;
+}
+
+void UnionFindRCUnionUtil(const std::string& v1, const std::string& v2, std::unordered_map<std::string, std::pair<std::string, int>>& subsets) {
+  const auto& p1 = UnionFindRCFindUtil(v1, subsets);
+  const auto& p2 = UnionFindRCFindUtil(v2, subsets);
+
+  if(subsets[p1].second > subsets[p2].second) {
+    subsets[p2].first = p1;
+  } else if(subsets[p1].second < subsets[p1].second) {
+    subsets[p1].first = p2;
+  } else {
+    subsets[p2].first = p1;
+    subsets[p1].second++;
+  }
+}
+
+std::random_device dev;
+std::mt19937 rng(dev());
+std::uniform_int_distribution<std::mt19937::result_type> dist(1000);
+
+void KargersAlgorithm(std::vector<Edge> edges, 
+                      std::size_t n_vertices,
+                      std::unordered_map<std::string, std::pair<std::string, int>> subsets,
+                      std::unordered_map<Edge, int, hasher>& answers) {
+  int count = edges.size();
+  while (n_vertices > 2) {
+    const auto idx = dist(rng) % (count);
+    const auto& edge = edges[idx];
+    const auto& p1 = UnionFindRCFindUtil(edge.start, subsets);
+    const auto& p2 = UnionFindRCFindUtil(edge.end, subsets);
+    if (p1 != p2) {
+      UnionFindRCUnionUtil(p1, p2, subsets);
+      n_vertices--;
+    }
+    count--;
+    std::swap(edges[idx], edges[count]);
+  }
+  for (int i = 0; i < count; i++) {
+    const auto& p1 = UnionFindRCFindUtil(edges[i].start, subsets);
+    const auto& p2 = UnionFindRCFindUtil(edges[i].end, subsets);
+    if (p1 != p2) {
+      answers[edges[i]]++;
+    }
+  }
+}
+
+int main(int argc, char * argv[]) {
+  std::string input = "../input/day_25_input";
+  if (argc > 1) {
+    input = argv[1];
+  }
+
+  std::string line;
+  std::fstream file(input);
+  std::unordered_set<Edge, hasher> edges_main;
+  while(std::getline(file, line)) {
+    parse_input(line, edges_main);
+  }
+
+  dist = std::uniform_int_distribution<std::mt19937::result_type>(edges_main.size());
+  std::unordered_set<std::string> vertices;
+  std::vector<Edge> edges_v;
+  for (const auto& edge : edges_main) {
+    vertices.insert(edge.start);
+    vertices.insert(edge.end);
+    edges_v.push_back(edge);
+  }
+  
+  std::unordered_map<Edge, int, hasher> answers;
+
+  std::unordered_map<std::string, std::pair<std::string, int>> subsets;
+  for (const auto& v : vertices) {
+    subsets[v] = {v, 0};
+  }
+  const auto n_vertices = vertices.size();
+  for (int iteration = 0; iteration < 10000; iteration++) {
+    if (iteration % 100 == 0) std::cout << "Iteration: " << iteration << '\n';
+    KargersAlgorithm(edges_v, n_vertices, subsets, answers);
+  }
+  // Create the edge list with the top 3 edges removed.
+  auto edges = edges_main;
+  { 
+    std::vector<std::pair<Edge, int>> answers_v;
+    for (const auto& [edge, count] : answers) {
+      answers_v.push_back({edge, count});
+    }
+    std::partial_sort(std::begin(answers_v), std::begin(answers_v) + 3, std::end(answers_v), [](const auto& e1, const auto& e2) { return e1.second > e2.second; });
+    edges.erase(answers_v[0].first);
+    edges.erase(answers_v[1].first);
+    edges.erase(answers_v[2].first);
+  }
+  // Find all the points connecting to a single (random) point to find one of the disjoint sets
+  std::unordered_map<std::string, std::unordered_set<std::string>> adj_list;
+  for (const auto& e : edges) {
+    adj_list[e.start].insert(e.end);
+    adj_list[e.end].insert(e.start);
+  }
+  std::stack<std::string> stack;
+  stack.push(adj_list.begin()->first);
+  std::unordered_set<std::string> seen;
+  while (!stack.empty()) {
+    const auto current = stack.top();
+    stack.pop();
+    if (seen.find(current) != seen.end()) {
+      continue;
+    }
+    seen.insert(current);
+    for (const auto& ele : adj_list[current]) {
+      if (seen.find(ele) == seen.end()) {
+        stack.push(ele);
+      }
+    }
+  }
+  std::cout << seen.size()  * (vertices.size() - seen.size()) << '\n';
+  return 0;
+}

2023/sample_input/day_20_sample_input

@@ -0,0 +1,5 @@
+broadcaster -> a, b, c
+%a -> b
+%b -> c
+%c -> inv
+&inv -> a

2023/sample_input/day_21_sample_input

@@ -0,0 +1,11 @@
+...........
+.....###.#.
+.###.##..#.
+..#.#...#..
+....#.#....
+.##..S####.
+.##..#...#.
+.......##..
+.##.#.####.
+.##..##.##.
+...........

2023/sample_input/day_22_sample_input

@@ -0,0 +1,7 @@
+1,0,1~1,2,1
+0,0,2~2,0,2
+0,2,3~2,2,3
+0,0,4~0,2,4
+2,0,5~2,2,5
+0,1,6~2,1,6
+1,1,8~1,1,9

2023/sample_input/day_23_sample_input

@@ -0,0 +1,23 @@
+#.#####################
+#.......#########...###
+#######.#########.#.###
+###.....#.>.>.###.#.###
+###v#####.#v#.###.#.###
+###.>...#.#.#.....#...#
+###v###.#.#.#########.#
+###...#.#.#.......#...#
+#####.#.#.#######.#.###
+#.....#.#.#.......#...#
+#.#####.#.#.#########v#
+#.#...#...#...###...>.#
+#.#.#v#######v###.###v#
+#...#.>.#...>.>.#.###.#
+#####v#.#.###v#.#.###.#
+#.....#...#...#.#.#...#
+#.#########.###.#.#.###
+#...###...#...#...#.###
+###.###.#.###v#####v###
+#...#...#.#.>.>.#.>.###
+#.###.###.#.###.#.#v###
+#.....###...###...#...#
+#####################.#

2023/sample_input/day_24_sample_input

@@ -0,0 +1,5 @@
+19, 13, 30 @ -2,  1, -2
+18, 19, 22 @ -1, -1, -2
+20, 25, 34 @ -2, -2, -4
+12, 31, 28 @ -1, -2, -1
+20, 19, 15 @  1, -5, -3

2023/sample_input/day_25_sample_input

@@ -0,0 +1,13 @@
+jqt: rhn xhk nvd
+rsh: frs pzl lsr
+xhk: hfx
+cmg: qnr nvd lhk bvb
+rhn: xhk bvb hfx
+bvb: xhk hfx
+pzl: lsr hfx nvd
+qnr: nvd
+ntq: jqt hfx bvb xhk
+nvd: lhk
+lsr: lhk
+rzs: qnr cmg lsr rsh
+frs: qnr lhk lsr

README.md

@@ -6,7 +6,7 @@ This repository contains solutions to the Advent of Code puzzles.
 
 | Year | C++ | Python | Link to folders | Link to README.md |
 |:----:|:----:|:----:|:----:|:----:|
-|2023  |1-19  | - | [Link](/2023/) |[Link](/2023/README.md) |
+|2023  |1-25  | - | [Link](/2023/) |[Link](/2023/README.md) |
 |2022  |1-25 | - | [Link](/2022/) |[Link](/2022/README.md) |
 |2021  |1-25 | - | [Link](/2021/) |[Link](/2021/README.md) |
 |2020  |1-25 |1-25 | [Link](/2020/) |[Link](/2020/README.md) |