Day 20 - Puzzle 2

Author: ariejan

lib/solutions/day_20.rb

@@ -8,7 +8,147 @@ def part_one(input)
   end
 
   def part_two(input)
-    0
+    sim = DayTwo.new(input)
+    results = sim.run!
+
+    top_results = results.select { |k,v| k >= 100 }
+    top_results.values.sum
+  end
+
+  class DayTwo
+    #Shamelessly stolen from day 16
+    DIRECTIONS = [
+      [0, -1],  # North
+      [1, 0],   # East
+      [0, 1],   # South
+      [-1, 0]   # West
+    ]
+    
+    TURN_COST = 1
+    MOVE_COST = 1
+
+    def initialize(input)
+      @grid = input.split("\n")
+      @cols = @grid[0].size
+      @rows = @grid.size
+
+      @start = find_cell('S')
+      @finish = find_cell('E')
+    end
+
+    def to_s
+      @grid.map { |r| r.join('') }
+    end
+
+    def n_step_reachable(x, y, n = 2)
+      result = []
+      first_step = neighbours(x, y)
+      first_step.each do |dx, dy|
+        second_step = neighbours(dx, dy)
+        second_step.each do |ddx, ddy|
+          ## ddx,ddy is reachable in 2 steps
+          result << [ddx, ddy] if @grid[ddy][ddx] != '#'
+        end
+      end
+      result
+    end
+
+    def run!
+      distances_start = bfs_distances(@start)
+      distances_finish = bfs_distances(@finish)
+
+      normal_time = distances_start[@finish[1]][@finish[0]]
+      return 0 if normal_time == Float::INFINITY
+
+      # Get only cells that are reachable from both start and finish
+      valid_cells = []
+      # puts @grid.inspect
+      (0...@rows).each do |y|
+        (0...@cols).each do |x|
+          next if @grid[y][x] == '#'
+          if distances_start[y][x] != Float::INFINITY && distances_finish[y][x] != Float::INFINITY
+            valid_cells << [x, y]
+          end
+        end
+      end
+
+      # Index cells by row to speed lookups:
+      valid_cells.sort_by!{|x,y| [x,y]}
+      by_row = Hash.new{|h,k| h[k]=[]}
+      valid_cells.each{|x,y| by_row[y] << [x,y]}
+
+      max_distance = 20
+      savings_count = Hash.new(0)
+
+      valid_cells.each do |x, y|
+        da = distances_start[y][x] 
+        
+        # Limit range of rows
+        min_y = [0, y - max_distance].max
+        max_y = [@rows - 1, y + max_distance].min
+
+        (min_y..max_y).each do |ry|
+          by_row[ry].each do |dx, dy|
+            m_dist = (x - dx).abs + (y - dy).abs
+            next if m_dist > max_distance
+            db = distances_finish[dy][dx]
+
+            cheat_time = da + m_dist + db
+            savings = normal_time - cheat_time
+            if savings > savings_count[[x,y,dx,dy]]
+              savings_count[savings] += 1 if savings > 0
+            end
+          end
+        end
+      end
+
+      # puts savings_count.inspect
+      savings_count
+    end
+
+    def neighbours(x, y)
+      [[x-1,y],[x+1,y],[x,y-1],[x,y+1]].select { |nx,ny| nx >= 0 && nx < @cols && ny >= 0 && ny < @rows }
+    end
+
+    def bfs_distances(start)
+      distances = Array.new(@rows) { Array.new(@cols, Float::INFINITY) }
+      distances[start[1]][start[0]] = 0
+      queue = [start]
+
+      head = 0
+      while head < queue.size
+        x, y = queue[head]
+        head += 1
+
+        neighbours(x, y).each do |dx, dy|
+          next if @grid[dy][dx] == '#'
+          next if distances[dy][dx] < Float::INFINITY
+
+          distances[dy][dx] = distances[y][x] + 1
+          queue << [dx, dy]
+        end
+      end
+
+      distances
+    end
+
+    def can_move?(x, y)
+      return false if x < 0 || x >= @cols
+      return false if y < 0 || y >= @rows
+      return false if @grid[y][x] == '#'
+      true
+    end
+      
+
+    def find_cell(ch)
+      @grid.each_with_index do |row, y|
+        x = row.index(ch)
+        if x
+          return [x, y]
+        end
+      end
+      nil
+    end
   end
 
   class DayOne

spec/solutions/day_20_spec.rb

@@ -6,7 +6,7 @@
 
   describe '#part_one' do
     it 'calculates the correct solutions for part one' do
-      results = subject.part_one(input)
+      results = Day20::DayOne.new(input).run!
 
       expect(results[2]).to eq(14)
       expect(results[4]).to eq(14)
@@ -24,7 +24,22 @@
 
   describe '#part_two' do
     it 'calculates the correct solutions for part two' do
-      expect(subject.part_two(input)).to eq(0)
+      results = Day20::DayTwo.new(input).run!
+
+      expect(results[50]).to eq(32)
+      expect(results[52]).to eq(31)
+      expect(results[54]).to eq(29)
+      expect(results[56]).to eq(39)
+      expect(results[58]).to eq(25)
+      expect(results[60]).to eq(23)
+      expect(results[62]).to eq(20)
+      expect(results[64]).to eq(19)
+      expect(results[66]).to eq(12)
+      expect(results[68]).to eq(14)
+      expect(results[70]).to eq(12)
+      expect(results[72]).to eq(22)
+      expect(results[74]).to eq(4)
+      expect(results[76]).to eq(3)
     end
   end
 end