day10 p2 as submitted

Author: Tom-Willemsen

aoc2025_wasm/src/impl_2025_10.rs

@@ -1,5 +1,7 @@
 use anyhow::{Context, Result, bail};
+use rayon::prelude::*;
 use std::{
+    cmp::Reverse,
     collections::{HashSet, VecDeque},
     str::FromStr,
 };
@@ -28,7 +30,7 @@ impl FromStr for InputLine {
             .map(|c| c == b'#')
             .collect::<Vec<_>>();
 
-        let wiring: Vec<Vec<usize>> = groups
+        let mut wiring: Vec<Vec<usize>> = groups
             .get(1..groups.len() - 1)
             .context("not enough groups")?
             .iter()
@@ -40,6 +42,8 @@ impl FromStr for InputLine {
             })
             .collect::<Result<_, _>>()?;
 
+        wiring.sort_unstable_by_key(|w| Reverse(w.len()));
+
         let joltages = groups
             .last()
             .context("not enough groups on line")?
@@ -104,15 +108,119 @@ fn calculate_p1_line(line: &InputLine) -> Result<u64> {
     bail!("no p1 solution");
 }
 
-fn calculate(inp: &str) -> Result<(u64, &str)> {
+fn calc_lower_bound(state: &[i32]) -> i32 {
+    *state.iter().max().unwrap_or(&i32::MAX)
+}
+
+fn calc_upper_bound(state: &[i32]) -> i32 {
+    state.iter().sum::<i32>()
+}
+
+fn make_inequalities(line: &InputLine) -> Result<Vec<Vec<(usize, usize)>>> {
+    // Inequalities where state[a] >= state[b] for a valid solution
+    let mut inequalities = vec![];
+
+    for btn_idx in 0..line.wiring.len() {
+        let mut ineq = vec![];
+        for a in 0..line.joltages.len() {
+            for b in 0..line.joltages.len() {
+                if a == b {
+                    continue;
+                }
+
+                if !line
+                    .wiring
+                    .iter()
+                    .skip(btn_idx)
+                    .any(|btn| btn.contains(&b) && !btn.contains(&a))
+                {
+                    ineq.push((a, b));
+                }
+            }
+        }
+        inequalities.push(ineq);
+    }
+    Ok(inequalities)
+}
+
+fn calculate_p2_line(line: &InputLine) -> Result<i32> {
+    // (state, num_pushes)
+    let mut q = vec![];
+
+    q.push((line.joltages.to_vec(), 0, 0));
+
+    let target_state = vec![0; line.joltages.len()];
+
+    let mut best = calc_upper_bound(&line.joltages);
+
+    // Inequalities where state[a] >= state[b] for a valid solution
+    let inequalities = make_inequalities(line)?;
+
+    while let Some((state, num_pushes, button_idx)) = q.pop() {
+        if state == target_state {
+            if num_pushes < best {
+                best = num_pushes;
+            }
+            continue;
+        }
+
+        let lower_bound = calc_lower_bound(&state);
+
+        if num_pushes + lower_bound >= best
+            || inequalities
+                .get(button_idx)
+                .unwrap_or(&vec![])
+                .iter()
+                .any(|(a, b)| {
+                    if let Some(a) = state.get(*a)
+                        && let Some(b) = state.get(*b)
+                    {
+                        a < b
+                    } else {
+                        true
+                    }
+                })
+        {
+            continue;
+        }
+
+        for button in button_idx..line.wiring.len() {
+            let mut new_state = state.clone();
+            let mut invalid = false;
+            for itm in line.wiring.get(button).unwrap_or(&vec![]).iter() {
+                let elem = new_state.get_mut(*itm).context("invalid itm")?;
+                *elem -= 1;
+                if *elem < 0 {
+                    invalid = true;
+                    break;
+                }
+            }
+
+            if invalid {
+                continue;
+            }
+
+            q.push((new_state, num_pushes + 1, button));
+        }
+    }
+
+    Ok(best)
+}
+
+fn calculate(inp: &str) -> Result<(u64, i32)> {
     let lines = inp
         .lines()
         .map(|line| line.parse())
         .collect::<Result<Vec<InputLine>>>()?;
 
     let p1 = lines.iter().map(calculate_p1_line).sum::<Result<u64>>()?;
 
-    Ok((p1, "p2 not implemented yet"))
+    let p2 = lines
+        .par_iter()
+        .map(calculate_p2_line)
+        .sum::<Result<i32>>()?;
+
+    Ok((p1, p2))
 }
 
 pub fn run_2025_10(inp: &str) -> Result<String> {
@@ -132,8 +240,13 @@ mod tests {
         assert_eq!(calculate(EXAMPLE_DATA).unwrap().0, 7);
     }
 
+    // #[test]
+    // fn test_real_p1() {
+    //     assert_eq!(calculate(REAL_DATA).unwrap().0, 422);
+    // }
+
     #[test]
-    fn test_real_p1() {
-        assert_eq!(calculate(REAL_DATA).unwrap().0, 422);
+    fn test_example_p2() {
+        assert_eq!(calculate(EXAMPLE_DATA).unwrap().1, 33);
     }
 }