chore: WIP for y2025::day_09::part_2

Author: clechasseur

.run/run_aoc.run.xml

@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="run_aoc" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
     <option name="buildProfileId" value="dev" />
-    <option name="command" value="run --package aoclp_solutions --bin aoclp_solutions -- --year 2025 --day 8" />
+    <option name="command" value="run --package aoclp_solutions --bin aoclp_solutions -- --year 2025 --day 9" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs />
     <option name="emulateTerminal" value="true" />

aoclp/src/positioning/pt.rs

@@ -178,7 +178,7 @@ where
 }
 
 /// Returns the size of the rectangle formed between two points in 2D space,
-/// as if the points were the rectangle's top-left and bottom-right corners.
+/// as if the points were two of the rectangle's opposing corners.
 pub fn rectangular_area<T>(a: Pt<T>, b: Pt<T>) -> T
 where
     T: Signed,

aoclp_solutions/src/y2025/day_09.rs

@@ -1,11 +1,11 @@
-use std::collections::{HashMap, HashSet};
-use std::hash::Hash;
-use std::iter::successors;
+use std::cmp::{max, min};
+use std::collections::{HashSet, VecDeque};
+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 strum::EnumIs;
+use aoclp::num::Zero;
 
 pub fn part_1() -> i64 {
     input()
@@ -16,37 +16,56 @@ pub fn part_1() -> i64 {
         .unwrap()
 }
 
-pub fn part_2() -> usize {
-    0
-}
+pub fn part_2() -> i64 {
+    let red_tiles = input();
 
-#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash, EnumIs)]
-enum Tile {
-    #[default]
-    Pink,
-    Red,
-    Green,
-}
+    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();
 
-#[derive(Debug, Clone)]
-struct Floor(HashMap<Pt, Tile>);
+    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;
 
-impl Default for Floor {
-    fn default() -> Self {
-        let tiles = input();
+    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 _path: HashSet<_> = tiles
-            .iter()
-            .tuple_windows()
-            .flat_map(|(a, b)| {
-                let displacement = Pt::new((b.x - a.x).signum(), (b.y - a.y).signum());
-                let b = *b;
-                successors(Some(*a), move |&p| (p != b).then_some(p + displacement))
+    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))
             })
-            .collect();
+            .all(|p| !lava.contains(&p))
+    };
 
-        todo!()
-    }
+    red_tiles
+        .into_iter()
+        .array_combinations()
+        .filter(|&[a, b]| safe_rectangle(a, b))
+        .map(|[a, b]| rectangular_area(a, b))
+        .max()
+        .unwrap()
 }
 
 fn input() -> Vec<Pt> {