2024: Optimize day 20

michel-kraemer · michel-kraemer · commit 04e1837f138f · 2024-12-20T12:48:02.000+01:00
diff --git a/2024/day20/src/main.rs b/2024/day20/src/main.rs
@@ -1,95 +1,111 @@
-use std::{
-    collections::{HashSet, VecDeque},
-    fs,
-};
+use std::fs;
 
-fn bfs(
+const DIRS: [(i32, i32); 4] = [(1, 0), (0, 1), (-1, 0), (0, -1)];
+
+fn find_non_branching_path(
     grid: &[u8],
     width: usize,
-    height: usize,
     start: (usize, usize),
     end: (usize, usize),
 ) -> Vec<(usize, usize)> {
-    let mut seen = HashSet::new();
-
-    let mut queue = VecDeque::new();
-    queue.push_back((start.0, start.1, vec![start]));
-
-    while let Some((x, y, path)) = queue.pop_front() {
-        if seen.contains(&(x, y)) {
-            continue;
+    // find start direction
+    let mut dir = 0;
+    for (i, d) in DIRS.iter().enumerate() {
+        let nx = start.0 as i32 + d.0;
+        let ny = start.1 as i32 + d.1;
+        if grid[ny as usize * width + nx as usize] != b'#' {
+            dir = i;
+            break;
         }
-        seen.insert((x, y));
+    }
 
-        if x == end.0 && y == end.1 {
-            return path;
-        }
+    // follow path and only turn right or left until we reach the end
+    let mut pos = start;
+    let mut result = vec![start];
+    while pos != end {
+        let nx = pos.0 as i32 + DIRS[dir].0;
+        let ny = pos.1 as i32 + DIRS[dir].1;
+
+        if grid[ny as usize * width + nx as usize] == b'#' {
+            // can we turn right?
+            let right = (dir + 1) % 4;
+            if grid[(pos.1 as i32 + DIRS[right].1) as usize * width
+                + (pos.0 as i32 + DIRS[right].0) as usize]
+                != b'#'
+            {
+                dir = right;
+                continue;
+            }
 
-        for (dx, dy) in [(1, 0), (0, 1), (-1, 0), (0, -1)] {
-            let nx = x as i32 + dx;
-            let ny = y as i32 + dy;
-            if nx >= 0
-                && ny >= 0
-                && nx < width as i32
-                && ny < height as i32
-                && grid[ny as usize * width + nx as usize] != b'#'
+            // can we turn left?
+            let left = (dir + 3) % 4;
+            if grid[(pos.1 as i32 + DIRS[left].1) as usize * width
+                + (pos.0 as i32 + DIRS[left].0) as usize]
+                != b'#'
             {
-                let mut new_path = path.clone();
-                new_path.push((nx as usize, ny as usize));
-                queue.push_back((nx as usize, ny as usize, new_path));
+                dir = left;
+                continue;
             }
+
+            // we're in a dead end
+            unreachable!("Path must not branch");
         }
+
+        pos = (nx as usize, ny as usize);
+        result.push(pos);
     }
 
-    unreachable!()
+    result
 }
 
 fn main() {
-    for part1 in [true, false] {
-        let input = fs::read_to_string("input.txt").expect("Could not read file");
-        let lines = input.lines().collect::<Vec<_>>();
-        let width = lines[0].len();
-        let height = lines.len();
-        let grid = lines
-            .iter()
-            .flat_map(|l| l.as_bytes())
-            .copied()
-            .collect::<Vec<_>>();
+    let input = fs::read_to_string("input.txt").expect("Could not read file");
+    let lines = input.lines().collect::<Vec<_>>();
+    let width = lines[0].len();
+    let height = lines.len();
+    let grid = lines
+        .iter()
+        .flat_map(|l| l.as_bytes())
+        .copied()
+        .collect::<Vec<_>>();
 
-        let mut start = (0, 0);
-        let mut end = (0, 0);
-        for y in 0..height {
-            for x in 0..width {
-                let c = grid[y * width + x];
-                if c == b'S' {
-                    start = (x, y);
-                } else if c == b'E' {
-                    end = (x, y);
-                }
+    let mut start = (0, 0);
+    let mut end = (0, 0);
+    for y in 0..height {
+        for x in 0..width {
+            let c = grid[y * width + x];
+            if c == b'S' {
+                start = (x, y);
+            } else if c == b'E' {
+                end = (x, y);
             }
         }
+    }
 
-        let path = bfs(&grid, width, height, start, end);
-        let max = path.len() - 1;
-        let max_cheat_len = if part1 { 2 } else { 20 };
+    let path = find_non_branching_path(&grid, width, start, end);
+    let max = path.len() - 1;
 
-        let mut total = 0;
-        for i in 0..path.len() {
-            for j in i + 1..path.len() {
-                let s = path[i];
-                let e = path[j];
-                let dist = (s.0.abs_diff(e.0) + s.1.abs_diff(e.1)) as usize;
-                if dist > max_cheat_len {
-                    continue;
-                }
+    let mut total1 = 0;
+    let mut total2 = 0;
+    for i in 0..path.len() {
+        for j in i + 101..path.len() {
+            let s = path[i];
+            let e = path[j];
+            let dist = s.0.abs_diff(e.0) + s.1.abs_diff(e.1);
+            let m = max - (j - i) + dist;
+            if m >= max || max - m < 100 {
+                continue;
+            }
 
-                let m = path.len() - (j - i + 1) + dist;
-                if m < max && max - m >= 100 {
-                    total += 1;
-                }
+            if dist <= 2 {
+                total1 += 1;
+            }
+            if dist <= 20 {
+                total2 += 1;
             }
         }
-
-        println!("{}", total);
     }
+
+    println!("{}", total1);
+    println!("{}", total2);
 }
