chore: WIP for y2025::day_09::part_2

Author: clechasseur

aoclp_solutions/src/y2025/day_09.rs

@@ -1,11 +1,10 @@
 use std::cmp::{max, min};
-use std::collections::{HashSet, VecDeque};
+use std::collections::HashMap;
 use std::iter::{once, successors};
-
 use aoclp::positioning::pt::{rectangular_area, Pt};
 use aoclp::solvers_impl::input::safe_get_input_as_many;
 use itertools::Itertools;
-use aoclp::num::Zero;
+use aoclp::positioning::direction::four_points::Direction4;
 
 pub fn part_1() -> i64 {
     input()
@@ -18,56 +17,84 @@ pub fn part_1() -> i64 {
 
 pub fn part_2() -> i64 {
     let red_tiles = input();
+    let path = build_path(&red_tiles);
 
-    let path: HashSet<_> = red_tiles
-        .iter()
-        .copied()
-        .chain(once(red_tiles[0]))
-        .enumerate()
-        .tuple_windows()
-        .flat_map(|((ia, a), (ib, b))| {
-            let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
-            if displacement.x != 0 && displacement.y != 0 {
-                panic!("Pair {} (#{ia}), {} (#{ib}) have wrong displacement", a.to_string(), b.to_string())
-            }
-            successors(Some(a), move |&p| (p != b).then_some(p + displacement))
-                .chain(once(b))
-        })
-        .collect();
-
-    let floor_width = red_tiles.iter().map(|p| p.x).max().unwrap() + 2;
-    let floor_height = red_tiles.iter().map(|p| p.y).max().unwrap() + 2;
-
-    let mut lava = HashSet::new();
-    let mut q = VecDeque::new();
-    q.push_back(Pt::zero());
-    while let Some(p) = q.pop_front() {
-        if !p.within(0..floor_width, 0..floor_height) || path.contains(&p) {
-            continue;
-        }
-        if lava.insert(p) {
-            q.extend(p.four_neighbours());
+    let safe_line = red_tiles.iter().map(|p| p.y).min().unwrap() - 1;
+    let mut pt_safety = HashMap::new();
+    let mut safe_pt = |p: Pt| {
+        if let Some(&safe) = pt_safety.get(&p) {
+            return safe;
         }
-    }
 
-    let safe_rectangle = |a: Pt, b: Pt| -> bool {
-        (min(a.y, b.y)..=max(a.y, b.y))
-            .into_iter()
-            .flat_map(|y| {
-                (min(a.x, b.x)..=max(a.x, b.x)).into_iter().map(move |x| Pt::new(x, y))
-            })
-            .all(|p| !lava.contains(&p))
+        let safe = successors(Some(p), |&p| (p.y > safe_line).then_some(p + Direction4::Up))
+            .filter(|p| path.get(p).is_some_and(|&step| step == PathStep::LeftRight))
+            .count() % 2 != 0;
+        pt_safety.insert(p, safe);
+        safe
+    };
+    let mut safe_line = |a: Pt, b: Pt| -> bool {
+        let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
+        successors(Some(a), |&p| (p != b).then_some(p + displacement)).chain(Some(b))
+            .all(|p| safe_pt(p))
+    };
+    let mut safe_rectangle = |a: Pt, b: Pt| {
+        let corners = [
+            Pt::new(min(a.x, b.x), min(a.y, b.y)),
+            Pt::new(min(a.x, b.x), max(a.y, b.y)),
+            Pt::new(max(a.x, b.x), max(a.y, b.y)),
+            Pt::new(max(a.x, b.x), min(a.y, b.y)),
+            Pt::new(min(a.x, b.x), min(a.y, b.y)),
+        ];
+        corners
+            .iter()
+            .tuple_windows()
+            .all(|(&a, &b)| safe_line(a, b))
     };
 
     red_tiles
         .into_iter()
         .array_combinations()
-        .filter(|&[a, b]| safe_rectangle(a, b))
-        .map(|[a, b]| rectangular_area(a, b))
-        .max()
+        .map(|[a, b]| (a, b, rectangular_area(a, b)))
+        .sorted_unstable_by(|(_, _, area_a), (_, _, area_b)| area_b.cmp(area_a))
+        .filter(|&(a, b, _)| safe_rectangle(a, b))
+        .map(|(_, _, area)| area)
+        .next()
         .unwrap()
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum PathStep {
+    Corner,
+    LeftRight,
+    TopDown,
+}
+
+impl PathStep {
+    fn for_pair(a: Pt, b: Pt) -> Self {
+        if (a.x - b.x).abs().signum() != 0 {
+            Self::LeftRight
+        } else {
+            Self::TopDown
+        }
+    }
+}
+
+fn build_path(red_tiles: &[Pt]) -> HashMap<Pt, PathStep> {
+    red_tiles
+        .iter()
+        .copied()
+        .chain(once(red_tiles[0]))
+        .tuple_windows()
+        .flat_map(|(a, b)| {
+            let step = PathStep::for_pair(a, b);
+            let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
+            successors(Some((a, PathStep::Corner)), move |&(p, _)| {
+                (p != b).then_some((p + displacement, step))
+            }).chain(once((b, PathStep::Corner)))
+        })
+        .collect()
+}
+
 fn input() -> Vec<Pt> {
     safe_get_input_as_many(2025, 9)
 }