Day 12

Author: petertseng

12_connected_groups.rb

@@ -0,0 +1,12 @@
+require_relative 'lib/union_find'
+
+neighbours = ARGF.to_h { |l|
+  left, right = l.split('<->')
+  [Integer(left), right.split(?,).map(&method(:Integer)).freeze]
+}.freeze
+
+uf = UnionFind.new(neighbours.keys, storage: Array)
+neighbours.each { |k, vs| vs.each { |v| uf.union_sz(k, v) } }
+
+puts uf.size(0)
+puts uf.num_sets

bench_rejected_impls/12_connected_groups.rb

@@ -0,0 +1,55 @@
+require_relative '../lib/search'
+require_relative '../lib/union_find'
+
+require 'benchmark'
+
+bench_candidates = []
+
+bench_candidates << def bfs(neighbours)
+  0.step { |i|
+    return i if neighbours.empty?
+
+    _, seen = Search::bfs(neighbours.keys.first, neighbours, ->(_) { false })
+
+    neighbours.delete_if { |k, _| seen.include?(k) }
+  }
+end
+
+# we do have to union by size for day 12,
+# but just for comparison:
+bench_candidates << def union_find_rank(neighbours)
+  nodes = neighbours.keys
+
+  uf = UnionFind.new(nodes, storage: Array)
+  neighbours.each { |k, vs| vs.each { |v| uf.union(k, v) } }
+
+  uf.num_sets
+end
+
+bench_candidates << def union_find_sz(neighbours)
+  nodes = neighbours.keys
+
+  uf = UnionFind.new(nodes, storage: Array)
+  neighbours.each { |k, vs| vs.each { |v| uf.union_sz(k, v) } }
+
+  uf.num_sets
+end
+
+neighbours = ARGF.to_h { |l|
+  left, right = l.split('<->')
+  [Integer(left), right.split(?,).map(&method(:Integer)).freeze]
+}.freeze
+
+results = {}
+
+Benchmark.bmbm { |bm|
+  bench_candidates.each { |f|
+    bm.report(f) { 100.times { results[f] = send(f, neighbours.dup) } }
+  }
+}
+
+# Obviously the benchmark would be useless if they got different answers.
+if results.values.uniq.size != 1
+  results.each { |k, v| puts "#{k} #{v}" }
+  raise 'differing answers'
+end

lib/search.rb

@@ -0,0 +1,19 @@
+require 'set'
+
+module Search
+  module_function
+
+  def bfs(start, neighbours, goal)
+    queue = [start]
+    seen = Set.new
+
+    while (n = queue.pop)
+      next if seen.include?(n)
+      return [true, n] if goal[n]
+      seen << n
+      queue.concat(neighbours[n])
+    end
+
+    [false, seen.freeze]
+  end
+end

lib/union_find.rb

@@ -0,0 +1,66 @@
+class UnionFind
+  attr_reader :num_sets
+
+  def initialize(things, storage: Hash)
+    @orig_things = things.freeze
+    @num_sets = things.size
+    if storage == Hash
+      @parent = things.map { |x| [x, x] }.to_h
+      @size = things.to_h { |x| [x, 1] }
+      @rank = things.map { |x| [x, 0] }.to_h
+    elsif storage == Array
+      m = things.max
+      @parent = Array.new(m + 1, &:itself)
+      @size = Array.new(m + 1, 1)
+      @rank = Array.new(m + 1, 0)
+    else raise "invalid storage #{storage}"
+    end
+  end
+
+  def size(x)
+    @size[find(x)]
+  end
+
+  def union(x, y)
+    xp = find(x)
+    yp = find(y)
+
+    return if xp == yp
+
+    if @rank[xp] < @rank[yp]
+      @parent[xp] = yp
+    elsif @rank[xp] > @rank[yp]
+      @parent[yp] = xp
+    else
+      @parent[yp] = xp
+      @rank[xp] += 1
+    end
+    @num_sets -= 1
+  end
+
+  # Just checking whether one's more expensive than the other
+  def union_sz(x, y)
+    xp = find(x)
+    yp = find(y)
+
+    return if xp == yp
+
+    if @size[xp] <= @size[yp]
+      @parent[xp] = yp
+      @size[yp] += @size[xp]
+    elsif @size[xp] > @size[yp]
+      @parent[yp] = xp
+      @size[xp] += @size[yp]
+    end
+    @num_sets -= 1
+  end
+
+  def find(x)
+    @parent[x] = find(@parent[x]) if @parent[x] != x
+    @parent[x]
+  end
+
+  def sets
+    @orig_things.group_by(&method(:find)).values.map(&:freeze).freeze
+  end
+end