Solve 2017/12, 2022/24, 2024/5

Author: code-shoily

lib/2017/day_12.ex

@@ -3,71 +3,45 @@ defmodule AdventOfCode.Y2017.Day12 do
   --- Day 12: Digital Plumber ---
   Problem Link: https://adventofcode.com/2017/day/12
   Difficulty: s
-  Tags: disjoint-set
+  Tags: graph connectivity
   """
-  alias AdventOfCode.Algorithms.DisjointSet
   alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog.Connectivity
+  alias Yog.Traversal
 
   def input, do: InputReader.read_from_file(2017, 12)
 
   def run(input \\ input()) do
-    disjoint_set = input |> parse() |> create_disjoint_set()
-    nodes = Map.keys(disjoint_set.parents)
+    graph = parse(input)
 
-    {run_1(disjoint_set, nodes), run_2(disjoint_set, nodes)}
+    {run_1(graph), run_2(graph)}
   end
 
-  defp run_1(disjoint_set, nodes) do
-    disjoint_set
-    |> find_connections_for(nodes, 0)
-    |> length()
-  end
-
-  defp run_2(disjoint_set, nodes) do
-    disjoint_set
-    |> find_groups(nodes)
+  defp run_1(graph) do
+    # Size of the connected component containing node 0
+    graph
+    |> Traversal.walk(0, :breadth_first)
     |> Enum.count()
   end
 
-  defp find_connections_for(disjoint_set, nodes, node) do
-    {target_parent, disjoint_set} = DisjointSet.find(disjoint_set, node)
-
-    nodes
-    |> Enum.reduce({[], disjoint_set}, fn x, {lst, set} ->
-      case DisjointSet.find(set, x) do
-        {^target_parent, new_set} -> {[x | lst], new_set}
-        {_, new_set} -> {lst, new_set}
-      end
-    end)
-    |> elem(0)
-  end
-
-  defp create_disjoint_set(input) do
-    disjoint_set = DisjointSet.new(Enum.count(input))
-
-    input
-    |> Enum.reduce(disjoint_set, fn {node, conns}, acc ->
-      Enum.reduce(conns, acc, fn y, s ->
-        DisjointSet.union(s, node, y)
-      end)
-    end)
-  end
-
-  defp find_groups(disj_set, nodes) do
-    nodes
-    |> Enum.reduce({MapSet.new(), disj_set}, fn x, {nodes, set} ->
-      {parent, new_set} = DisjointSet.find(set, x)
-      {MapSet.put(nodes, parent), new_set}
-    end)
-    |> elem(0)
+  defp run_2(graph) do
+    # Number of connected components in the graph
+    graph
+    |> Connectivity.connected_components()
+    |> Enum.count()
   end
 
   def parse(data \\ input()) do
     data
     |> Transformers.lines()
-    |> Map.new(fn line ->
+    |> Enum.reduce(Yog.undirected(), fn line, graph ->
       [node, connections] = line |> String.split(" <-> ")
-      {String.to_integer(node), Transformers.int_words(connections, ", ")}
+      u = String.to_integer(node)
+      dests = Transformers.int_words(connections, ", ")
+
+      Enum.reduce(dests, graph, fn v, acc ->
+        Yog.add_edge_ensure(acc, u, v, 1, nil)
+      end)
     end)
   end
 end

lib/2022/day_24.ex

@@ -3,13 +3,122 @@ defmodule AdventOfCode.Y2022.Day24 do
   --- Day 24: Blizzard Basin ---
   Problem Link: https://adventofcode.com/2022/day/24
   Difficulty: m
-  Tags: erlang slow optimization grid search
+  Tags: graph implicit-graph shortest-path a-star
   """
   alias AdventOfCode.Helpers.InputReader
+  alias Yog.Pathfinding.AStar
 
   def input, do: InputReader.read_from_file(2022, 24)
 
   def run(input \\ input()) do
-    :day_22_24.solve(input)
+    {up, down, left, right, w, h} = parse(input)
+
+    inner_w = w - 2
+    inner_h = h - 2
+    # LCM of dimensions for blizzard cycle
+    # For AoC 120x25 or similar, LCM is small enough
+    cycle = lcm(inner_w, inner_h)
+
+    start_pos = {1, 0}
+    goal_pos = {inner_w, h - 1}
+
+    # Part 1: Start to Goal
+    {:ok, t1} = solve_path(start_pos, goal_pos, 0, up, down, left, right, w, h, cycle)
+
+    # Part 2: Back to Start, then back to Goal
+    {:ok, t2} = solve_path(goal_pos, start_pos, t1, up, down, left, right, w, h, cycle)
+    {:ok, t3} = solve_path(start_pos, goal_pos, t2, up, down, left, right, w, h, cycle)
+
+    {t1, t3}
+  end
+
+  defp solve_path({sx, sy}, {gx, gy}, start_t, up, down, left, right, w, h, cycle) do
+    inner_w = w - 2
+    inner_h = h - 2
+
+    is_valid = fn x, y, t ->
+      cond do
+        {x, y} == {sx, sy} -> true
+        {x, y} == {gx, gy} -> true
+        x <= 0 or x > inner_w or y <= 0 or y > inner_h -> false
+        true -> not has_blizzard?(x, y, t, up, down, left, right, inner_w, inner_h, w)
+      end
+    end
+
+    successors = fn {x, y, t} ->
+      nt = t + 1
+
+      [{x, y}, {x, y - 1}, {x, y + 1}, {x - 1, y}, {x + 1, y}]
+      |> Enum.filter(fn {nx, ny} -> is_valid.(nx, ny, nt) end)
+      |> Enum.map(fn {nx, ny} -> {{nx, ny, nt}, 1} end)
+    end
+
+    visited_by = fn {x, y, t} -> {x, y, rem(t, cycle)} end
+    is_goal = fn {x, y, _t} -> {x, y} == {gx, gy} end
+    heuristic = fn {x, y, _t} -> abs(gx - x) + abs(gy - y) end
+
+    AStar.implicit_a_star_by(
+      from: {sx, sy, start_t},
+      successors_with_cost: successors,
+      visited_by: visited_by,
+      is_goal: is_goal,
+      heuristic: heuristic
+    )
+    |> case do
+      {:ok, cost} -> {:ok, start_t + cost}
+      :error -> :error
+    end
+  end
+
+  defp has_blizzard?(x, y, t, up, down, left, right, iw, ih, w) do
+    # At time t, a tile (x, y) is occupied if:
+    # An '^' blizzard was at (x, (y-1+t) % ih + 1)
+    # A 'v' blizzard was at (x, (y-1-t) % ih + 1)
+    # A '<' blizzard was at ((x-1+t) % iw + 1, y)
+    # A '>' blizzard was at ((x-1-t) % iw + 1, y)
+
+    uy = rem_euclid(y - 1 + t, ih) + 1
+    dy = rem_euclid(y - 1 - t, ih) + 1
+    lx = rem_euclid(x - 1 + t, iw) + 1
+    rx = rem_euclid(x - 1 - t, iw) + 1
+
+    MapSet.member?(up, uy * w + x) or
+      MapSet.member?(down, dy * w + x) or
+      MapSet.member?(left, y * w + lx) or
+      MapSet.member?(right, y * w + rx)
+  end
+
+  defp parse(input) do
+    lines = input |> String.trim() |> String.split("\n")
+    h = length(lines)
+    w = String.length(hd(lines))
+
+    points =
+      for {line, y} <- Enum.with_index(lines),
+          {char, x} <- Enum.with_index(String.graphemes(line)),
+          char in ["^", "v", "<", ">"] do
+        {y * w + x, char}
+      end
+
+    up = filter_points(points, "^")
+    down = filter_points(points, "v")
+    left = filter_points(points, "<")
+    right = filter_points(points, ">")
+
+    {up, down, left, right, w, h}
+  end
+
+  defp filter_points(points, char) do
+    points
+    |> Enum.filter(fn {_, c} -> c == char end)
+    |> Enum.map(fn {pos, _} -> pos end)
+    |> MapSet.new()
+  end
+
+  defp lcm(a, b), do: div(abs(a * b), Integer.gcd(a, b))
+
+  defp rem_euclid(a, b) do
+    r = rem(a, b)
+    if r < 0, do: r + b, else: r
   end
 end

lib/2024/day_05.ex

@@ -3,50 +3,91 @@ defmodule AdventOfCode.Y2024.Day05 do
   --- Day 5: Print Queue ---
   Problem Link: https://adventofcode.com/2024/day/5
   Difficulty: xs
-  Tags: set sort
+  Tags: graph topological-sort sort
   """
   alias AdventOfCode.Helpers.{InputReader, Transformers}
+  alias Yog.Traversal
 
   def input, do: InputReader.read_from_file(2024, 5)
 
   def run(input \\ input()) do
-    input = parse(input)
+    {rules, updates} = parse(input)
 
-    {run_1(input), run_2(input)}
+    # Process all updates based on the rules.
+    # For each update, we produce a correctly ordered version using topological sort.
+    processed =
+      for update <- updates do
+        reordered = reorder(update, rules)
+        {update, reordered}
+      end
+
+    {run_1(processed), run_2(processed)}
+  end
+
+  defp run_1(processed) do
+    processed
+    |> Enum.filter(fn {original, reordered} -> original == reordered end)
+    |> Enum.sum_by(fn {reordered, _} -> get_middle(reordered) end)
   end
 
-  defp run_1(input) do
-    input
-    |> Enum.filter(fn {a, b} -> a == b end)
-    |> Enum.sum_by(fn {a, _} -> a |> Enum.at(div(length(a), 2)) end)
+  defp run_2(processed) do
+    processed
+    |> Enum.filter(fn {original, reordered} -> original != reordered end)
+    |> Enum.sum_by(fn {_, reordered} -> get_middle(reordered) end)
   end
 
-  defp run_2(input) do
-    input
-    |> Enum.filter(fn {a, b} -> a != b end)
-    |> Enum.sum_by(fn {_, b} -> b |> Enum.at(div(length(b), 2)) end)
+  defp get_middle(list) do
+    Enum.at(list, div(length(list), 2))
   end
 
   def parse(data \\ input()) do
-    [deps, updates] = Transformers.sections(data)
-    given_sorted_pair({parse_deps(deps), parse_updates(updates)})
+    [rules_raw, updates_raw] = Transformers.sections(data)
+    {parse_rules(rules_raw), parse_updates(updates_raw)}
   end
 
-  defp parse_deps(deps) do
-    for line <- Transformers.lines(deps),
-        into: MapSet.new(),
-        do: String.split(line, "|") |> Enum.map(&String.to_integer/1) |> List.to_tuple()
+  defp parse_rules(raw) do
+    for line <- Transformers.lines(raw) do
+      [a, b] = String.split(line, "|") |> Enum.map(&String.to_integer/1)
+      {a, b}
+    end
   end
 
-  defp parse_updates(updates) do
-    for line <- Transformers.lines(updates) do
-      for update <- String.split(line, ","), do: String.to_integer(update)
+  defp parse_updates(raw) do
+    for line <- Transformers.lines(raw) do
+      line |> String.split(",") |> Enum.map(&String.to_integer/1)
     end
   end
 
-  defp given_sorted_pair({deps, updates}) do
-    for update <- updates do
-      {update, Enum.sort(update, &({&1, &2} in deps))}
+  # Reorder an update by building a dependency graph and performing a topological sort.
+  defp reorder(update, rules) do
+    update_set = MapSet.new(update)
+
+    # Filter rules that only apply to the current set of pages.
+    active_rules =
+      Enum.filter(rules, fn {a, b} ->
+        MapSet.member?(update_set, a) and MapSet.member?(update_set, b)
+      end)
+
+    # Build a directed graph of dependencies.
+    graph =
+      Enum.reduce(active_rules, Yog.directed(), fn {a, b}, acc ->
+        Yog.add_edge_ensure(acc, a, b, 1, nil)
+      end)
+
+    # Ensure all pages in the update are represented in the graph.
+    graph =
+      Enum.reduce(update, graph, fn page, acc ->
+        if Yog.has_node?(acc, page) do
+          acc
+        else
+          Yog.add_node(acc, page, nil)
+        end
+      end)
+
+    # Correct sequence is the topological order of these dependencies.
+    case Traversal.topological_sort(graph) do
+      {:ok, sorted} -> sorted
+      {:error, :contains_cycle} -> update
     end
   end
 end