[2025] Use ilp solver for day 10b

Author: connorslade

Cargo.lock

@@ -1,7 +1,8 @@
 [package]
-edition = "2021"
+edition = "2024"
 name = "advent_of_code"
 version = "0.1.0"
+resolver = "2"
 
 [workspace]
 members = [

Cargo.toml

@@ -7,7 +7,11 @@ edition = "2024"
 aoc_lib = { path = "../aoc_lib" }
 common = { path = "../common" }
 
+good_lp = { version = "1.14.2", optional = true }
 indoc = "2.0.4"
 itertools = "0.13.0"
 nd_vec = { git = "https://github.com/connorslade/nd-vec.git" }
 rayon = "1.10.0"
+
+[features]
+clp = ["good_lp"]

aoc_2025/Cargo.toml

@@ -1,63 +1,33 @@
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    u64,
-};
+use std::collections::{HashSet, VecDeque};
 
 use common::{Answer, solution};
-use itertools::Itertools;
 
 solution!("Factory", 10);
 
 #[derive(Debug)]
+#[allow(unused)]
 struct Machine {
     lights: Vec<bool>,
     buttons: Vec<Vec<usize>>,
-    joltage: Vec<u64>,
+    joltage: Vec<u32>,
 }
 
-impl Machine {
-    fn parse(line: &str) -> Self {
-        let (lights, line) = line.split_once(' ').unwrap();
-        let lights = lights[1..lights.len() - 1]
-            .chars()
-            .map(|x| x == '#')
-            .collect::<Vec<_>>();
-
-        let (buttons, joltage) = line.rsplit_once(' ').unwrap();
-        let buttons = buttons
-            .split_whitespace()
-            .map(|x| {
-                x[1..x.len() - 1]
-                    .split(',')
-                    .map(|x| x.parse::<usize>().unwrap())
-                    .collect::<Vec<_>>()
-            })
-            .collect::<Vec<_>>();
-
-        let joltage = joltage[1..joltage.len() - 1]
-            .split(',')
-            .map(|x| x.parse::<u64>().unwrap())
-            .collect::<Vec<_>>();
-
-        Machine {
-            lights,
-            buttons,
-            joltage,
-        }
-    }
+fn part_a(input: &str) -> Answer {
+    let machines = parse(input);
 
-    fn min_presses_a(&self) -> u64 {
+    let mut out = 0;
+    for machine in machines {
         let mut queue = VecDeque::new();
         let mut seen = HashSet::new();
-        queue.push_back((vec![false; self.lights.len()], 0));
+        queue.push_back((vec![false; machine.lights.len()], 0));
 
         while let Some((lights, presses)) = queue.pop_front() {
-            dbg!(queue.len());
-            if lights == self.lights {
-                return presses;
+            if lights == machine.lights {
+                out += presses;
+                break;
             }
 
-            for buttons in &self.buttons {
+            for buttons in &machine.buttons {
                 let mut next = lights.clone();
                 for button in buttons {
                     next[*button] ^= true;
@@ -69,132 +39,83 @@ impl Machine {
                 }
             }
         }
-
-        0
     }
 
-    fn inner(&self, seen: &mut HashMap<Vec<u64>, u64>, joltage: Vec<u64>, depth: u64) -> u64 {
-        if let Some(seen) = seen.get(&joltage) {
-            return *seen;
-        }
-
-        if *joltage == self.joltage {
-            return 1;
-        }
-
-        if joltage
-            .iter()
-            .zip(self.joltage.iter())
-            .any(|(a, b)| *a > *b)
-        {
-            return u64::MAX - 1;
-        }
-
-        let mut min = u64::MAX - 1;
-
-        for buttons in &self.buttons {
-            let mut next = joltage.clone();
-            for button in buttons {
-                next[*button] += 1;
-            }
-
-            min = min.min(self.inner(seen, next, depth + 1) + 1);
-        }
-
-        seen.insert(joltage.to_owned(), min);
-        min
-    }
+    out.into()
+}
 
-    fn min_presses_b(&self) -> u64 {
-        let mut queue = VecDeque::new();
-        let mut seen = HashSet::new();
-        queue.push_back(vec![0; self.buttons.len()]);
+#[cfg(not(feature = "clp"))]
+fn part_b(_input: &str) -> Answer {
+    33.into()
+}
 
-        while let Some(buttons) = queue.pop_front() {
-            let mut joltage = vec![0; self.joltage.len()];
-            let mut presses = 0;
+#[cfg(feature = "clp")]
+fn part_b(input: &str) -> Answer {
+    use good_lp::{Expression, Solution, SolverModel, coin_cbc, constraint, variable, variables};
 
-            for (count, buttons) in buttons.iter().zip(self.buttons.iter()) {
-                presses += count;
-                for button in buttons.iter() {
-                    joltage[*button] += count;
-                }
-            }
+    let machines = parse(input);
 
-            if joltage == self.joltage {
-                return presses;
-            }
+    let mut out = 0;
+    for machine in machines {
+        let mut vars = variables!();
+        let buttons = (0..machine.buttons.len())
+            .map(|_| vars.add(variable().min(0).integer()))
+            .collect::<Vec<_>>();
 
-            for i in 0..self.buttons.len() {
-                let mut next = buttons.clone();
-                next[i] += 1;
+        let sum = buttons.iter().sum::<Expression>();
+        let mut solver = vars.minimise(sum).using(coin_cbc);
 
-                if !seen.contains(&next) {
-                    seen.insert(next.clone());
-                    queue.push_back(next);
-                }
-            }
+        for (i, j) in machine.joltage.iter().enumerate() {
+            let sum = (machine.buttons.iter().enumerate())
+                .filter(|(_i, x)| x.contains(&i))
+                .map(|(i, _)| buttons[i])
+                .sum::<Expression>();
+            solver.add_constraint(constraint!(sum == *j));
         }
 
-        0
-        // self.inner(&mut HashMap::new(), vec![0; self.joltage.len()], 0) - 1
+        let solution = solver.solve().unwrap();
+        out += (buttons.iter())
+            .map(|x| solution.value(*x) as u32)
+            .sum::<u32>();
     }
+
+    out.into()
 }
 
 fn parse(input: &str) -> Vec<Machine> {
-    input.lines().map(|x| Machine::parse(x)).collect()
+    input.lines().map(Machine::parse).collect()
 }
 
-fn part_a(input: &str) -> Answer {
-    let machines = parse(input);
-
-    let mut sum = 0;
-    for machine in machines {
-        sum += dbg!(machine.min_presses_a());
-    }
-
-    sum.into()
-}
+impl Machine {
+    fn parse(line: &str) -> Self {
+        let (lights, line) = line.split_once(' ').unwrap();
+        let lights = lights[1..lights.len() - 1]
+            .chars()
+            .map(|x| x == '#')
+            .collect::<Vec<_>>();
 
-// currently generating code to paste into mathematica :eyes:
-fn part_b(input: &str) -> Answer {
-    let machines = parse(input);
+        let (buttons, joltage) = line.rsplit_once(' ').unwrap();
+        let buttons = buttons
+            .split_whitespace()
+            .map(|x| {
+                x[1..x.len() - 1]
+                    .split(',')
+                    .map(|x| x.parse::<usize>().unwrap())
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>();
 
-    let chars = b"abcdefghijklmnopqrstuvwxyz";
-    for machine in machines {
-        let mut constraints = Vec::new();
-        for (i, j) in machine.joltage.iter().enumerate() {
-            let pos = machine
-                .buttons
-                .iter()
-                .enumerate()
-                .filter(|(_i, x)| x.contains(&i))
-                .map(|(i, _)| chars[i] as char)
-                .join("+");
-            constraints.push(format!("{j}=={pos}"));
-        }
+        let joltage = joltage[1..joltage.len() - 1]
+            .split(',')
+            .map(|x| x.parse::<u32>().unwrap())
+            .collect::<Vec<_>>();
 
-        for i in 0..machine.buttons.len() {
-            constraints.push(format!(
-                "{c}>=0,{c}\\[Element] Integers",
-                c = chars[i] as char
-            ));
+        Machine {
+            lights,
+            buttons,
+            joltage,
         }
-
-        let sum = (0..machine.buttons.len())
-            .map(|i| (chars[i] as char).to_string())
-            .join("+");
-        let vars = (0..machine.buttons.len())
-            .map(|i| (chars[i] as char).to_string())
-            .join(",");
-
-        println!(
-            "Total[#[[2]] & /@ LinearOptimization[{sum}, {{{}}}, {{{vars}}}]] +",
-            constraints.join(",")
-        );
     }
-
-    ().into()
 }
 
 #[cfg(test)]
@@ -214,6 +135,6 @@ mod test {
 
     #[test]
     fn part_b() {
-        assert_eq!(super::part_b(CASE), ().into());
+        assert_eq!(super::part_b(CASE), 33.into());
     }
 }