Populate grid lazily (#40)

Rather than populating 2704 cells up front, then running the maze
until all (reachable) cells have been visited, it is more efficient to
populate the grid as we explore, and to quit exploring as soon as we
have our answer.  Cuts runtime from 6.4us to 3.1us on my machine.

It is not worth the overhead of trying to steer the part 1 solution
with an A* search.

Author: ebblake

src/year2016/day13.rs

@@ -4,8 +4,10 @@
 //! [BFS](https://en.wikipedia.org/wiki/Breadth-first_search) solving both part one and part
 //! two simultaneously.
 //!
-//! As we start at (1, 1) and the most steps that we are interested in is 50, we can bound
-//! the maze to 2 + 50 = 52 in each dimension and used a fixed size array.
+//! As we start at (1, 1) and the most steps that we are interested in for part 2 is 50, while
+//! part 1 requires more than 50 steps but should easily be reachable without exceeding bounds,
+//! we can bound the maze to 2 + 50 = 52 in each dimension and use a fixed size array.  Rather
+//! than filling the array up front, we can lazily populate it as the horizon expands.
 
 use crate::util::parse::*;
 use std::collections::VecDeque;
@@ -14,49 +16,47 @@ type Input = (u32, u32);
 
 pub fn parse(input: &str) -> Input {
     let favorite: usize = input.unsigned();
-    let mut maze = [[false; 52]; 52];
 
-    for (x, row) in maze.iter_mut().enumerate() {
-        for (y, cell) in row.iter_mut().enumerate() {
-            let n = (x * x) + (3 * x) + (2 * x * y) + y + (y * y) + favorite;
-            *cell = n.count_ones().is_multiple_of(2);
+    // Lazy evaluation: set maze[x][y] to true once a point is visited
+    let mut maze = [[false; 52]; 52];
+    maze[1][1] = true;
+    let mut at = |x: usize, y: usize| -> bool {
+        if maze[x][y] {
+            return false;
         }
-    }
+        maze[x][y] = true;
+        let n = (x * x) + (3 * x) + (2 * x * y) + y + (y * y) + favorite;
+        n.count_ones().is_multiple_of(2)
+    };
 
-    let mut part_one = 0;
     let mut part_two = 0;
     let mut todo = VecDeque::new();
 
     todo.push_back((1, 1, 0));
-    maze[1][1] = false;
 
     while let Some((x, y, cost)) = todo.pop_front() {
         if x == 31 && y == 39 {
-            part_one = cost;
+            return (cost, part_two);
         }
         if cost <= 50 {
             part_two += 1;
         }
 
-        if x > 0 && maze[x - 1][y] {
+        if x > 0 && at(x - 1, y) {
             todo.push_back((x - 1, y, cost + 1));
-            maze[x - 1][y] = false;
         }
-        if y > 0 && maze[x][y - 1] {
+        if y > 0 && at(x, y - 1) {
             todo.push_back((x, y - 1, cost + 1));
-            maze[x][y - 1] = false;
         }
-        if x < 51 && maze[x + 1][y] {
+        if at(x + 1, y) {
             todo.push_back((x + 1, y, cost + 1));
-            maze[x + 1][y] = false;
         }
-        if y < 51 && maze[x][y + 1] {
+        if at(x, y + 1) {
             todo.push_back((x, y + 1, cost + 1));
-            maze[x][y + 1] = false;
         }
     }
 
-    (part_one, part_two)
+    unreachable!();
 }
 
 pub fn part1(input: &Input) -> u32 {