127 lines
3.2 KiB
Markdown
127 lines
3.2 KiB
Markdown
# AOC 2024 Day 23
|
|
|
|
## Section
|
|
|
|
```elixir
|
|
defmodule LANGraph do
|
|
defstruct nodes: MapSet.new, edges: MapSet.new
|
|
@doc """
|
|
For a graph, counts the number of cycles of size `size` in the graph.
|
|
"""
|
|
def cycles(graph, 3) do
|
|
nodes = graph.nodes
|
|
|
|
nodes
|
|
|> Enum.flat_map(
|
|
fn v -> find_cycle(graph, v, v, [], 3, 0) end
|
|
)
|
|
end
|
|
|
|
def find_cycle(_, _, _, path, n, y) when y == n, do: [path]
|
|
def find_cycle(graph, start, v, path, depth, curr) do
|
|
is_next_node? = fn u ->
|
|
if curr == (depth - 1), do: u == start, else: Enum.all?(path, &(&1 != u))
|
|
end
|
|
|
|
outE(graph, v)
|
|
|> Stream.map(fn {uu, vv} -> if uu == v, do: vv, else: uu end)
|
|
|> Stream.filter(is_next_node?)
|
|
|> Enum.flat_map(&find_cycle(graph, start, &1, [v | path], depth, curr + 1))
|
|
end
|
|
|
|
defp outE(graph, vertex) do
|
|
graph.edges
|
|
|> Enum.filter(&(elem(&1,0) == vertex or elem(&1,1) == vertex))
|
|
end
|
|
|
|
def add_edge(graph, {a, b} = edge) do
|
|
%LANGraph{
|
|
nodes: graph.nodes |> MapSet.put(a) |> MapSet.put(b),
|
|
edges: graph.edges |> MapSet.put(edge)
|
|
}
|
|
end
|
|
|
|
def neighbors(graph, vertex) do
|
|
graph.edges
|
|
|> Stream.filter(&(elem(&1, 0) == vertex or elem(&1, 1) == vertex))
|
|
|> Enum.map(fn
|
|
{^vertex, b} -> b
|
|
{b, ^vertex} -> b
|
|
end)
|
|
end
|
|
|
|
@empty MapSet.new([])
|
|
def bron_kerbosch(g) do
|
|
neighbor_set = fn v ->
|
|
neighbors(g, v) |> MapSet.new()
|
|
end
|
|
bron_kerbosch(MapSet.new, g.nodes, MapSet.new, neighbor_set, [])
|
|
end
|
|
|
|
def bron_kerbosch(r,o,o,_,acc) when o == @empty, do: [r | acc]
|
|
def bron_kerbosch(_,o,_,_,acc) when o == @empty, do: acc
|
|
def bron_kerbosch(r,p,x,n,acc) do
|
|
for v <- p,
|
|
n_v = n.(v),
|
|
reduce: {p, x, acc} do
|
|
{p, x, acc} ->
|
|
acc = bron_kerbosch(MapSet.put(r, v), MapSet.intersection(p, n_v), MapSet.intersection(x, n_v), n, acc)
|
|
{p |> MapSet.delete(v), x |> MapSet.put(v), acc}
|
|
end |> elem(2)
|
|
end
|
|
|
|
def parse(input), do: input
|
|
|> String.split("\n", trim: true)
|
|
|> Stream.map(fn <<a::binary-size(2)>> <> "-" <> <<b::binary-size(2)>> ->
|
|
{a |> String.to_atom, b |> String.to_atom}
|
|
end)
|
|
|> Enum.reduce(%LANGraph{}, fn e, acc -> LANGraph.add_edge(acc, e) end)
|
|
|
|
def part1(input) do
|
|
connections = input |> parse()
|
|
|
|
t_nodes = connections.nodes|> Stream.filter(&String.starts_with?(Atom.to_string(&1), "t")) |> Enum.into(MapSet.new)
|
|
three_cycles = connections
|
|
|> LANGraph.cycles(3)
|
|
|> Enum.map(&Enum.into(&1, MapSet.new()))
|
|
|> Enum.into(MapSet.new)
|
|
three_cycles
|
|
|> Stream.filter(&Enum.any?(t_nodes, fn t -> MapSet.member?(&1, t) end))
|
|
|> Enum.count()
|
|
end
|
|
|
|
def part2(input) do
|
|
input
|
|
|> parse()
|
|
|> bron_kerbosch()
|
|
|> Enum.max_by(&MapSet.size/1)
|
|
|> Stream.map(&Atom.to_string/1)
|
|
|> Enum.sort
|
|
|> Enum.join(",")
|
|
end
|
|
end
|
|
```
|
|
|
|
## Input
|
|
|
|
```elixir
|
|
input = """
|
|
"""
|
|
|
|
connections = input |> String.split("\n", trim: true)
|
|
|> Stream.map(fn <<a::binary-size(2)>> <> "-" <> <<b::binary-size(2)>> ->
|
|
{a |> String.to_atom, b |> String.to_atom}
|
|
end)
|
|
|> Enum.reduce(%LANGraph{}, fn e, acc -> LANGraph.add_edge(acc, e) end)
|
|
|
|
```
|
|
|
|
## Solution
|
|
|
|
```elixir
|
|
LANGraph.part1(input)
|
|
```
|
|
|
|
```elixir
|
|
LANGraph.part2(input)
|
|
```
|