Tidy

Author: maneatingape

src/year2023/day16.rs

@@ -58,7 +58,7 @@ impl BitSet {
     }
 
     fn union(&mut self, other: &BitSet) {
-        self.bits.iter_mut().zip(other.bits.iter()).for_each(|(a, b)| *a |= b);
+        self.bits.iter_mut().zip(&other.bits).for_each(|(a, b)| *a |= b);
     }
 
     fn size(&self) -> u32 {
@@ -236,8 +236,8 @@ fn strong_connect(graph: &mut Graph, position: Point) -> usize {
         {
             let other = &graph.nodes[next];
             node.tiles.union(&other.tiles);
-            node.from.extend(other.from.iter());
-            node.to.extend(other.to.iter());
+            node.from.extend(&other.from);
+            node.to.extend(&other.to);
         }
 
         // Mark node as done.

src/year2023/day23.rs

@@ -209,8 +209,8 @@ pub fn part1(input: &Input) -> u32 {
 
     for y in 0..6 {
         for x in 0..6 {
-            let left = if x == 0 { 0 } else { total[y][x - 1] + input.horizontal[y][x - 1] };
-            let above = if y == 0 { 0 } else { total[y - 1][x] + input.vertical[y - 1][x] };
+            let left = if x > 0 { total[y][x - 1] + input.horizontal[y][x - 1] } else { 0 };
+            let above = if y > 0 { total[y - 1][x] + input.vertical[y - 1][x] } else { 0 };
             total[y][x] = left.max(above);
         }
     }
@@ -255,15 +255,17 @@ pub fn part2(input: &Input) -> u32 {
         for ((row, gap), steps) in current.drain() {
             for &(next_row, next_gap, horizontal, vertical) in &graph[&row] {
                 // Only 1 gap total is allowed, otherwise we can make a longer path.
-                if !(gap && next_gap) {
-                    // The bit sets represent the horizonal and vertical moves from the
-                    // previous row.
-                    let extra = horizontal.biterator().map(|x| input.horizontal[y][x]).sum::<u32>()
-                        + vertical.biterator().map(|x| input.vertical[y][x]).sum::<u32>();
-
-                    let e = next.entry((next_row, gap || next_gap)).or_insert(0);
-                    *e = (*e).max(steps + extra);
+                if gap && next_gap {
+                    continue;
                 }
+
+                // The bit sets represent the horizontal and vertical moves from the previous row.
+                let extra = horizontal.biterator().map(|x| input.horizontal[y][x]).sum::<u32>()
+                    + vertical.biterator().map(|x| input.vertical[y][x]).sum::<u32>();
+
+                // De-duplicate states so that each row has at most 76 states.
+                let e = next.entry((next_row, gap || next_gap)).or_insert(0);
+                *e = (*e).max(steps + extra);
             }
         }
 
@@ -274,7 +276,7 @@ pub fn part2(input: &Input) -> u32 {
     input.extra + current[&(end, true)]
 }
 
-/// Convert maze to unidrected graph.
+/// Convert maze to undirected graph.
 fn compress(input: &str) -> Graph {
     let mut grid = Grid::parse(input);
     let width = grid.width;