Day 12 part 2

2021/src/day12.rs

@@ -39,7 +39,6 @@ fn search(node: &str, nodes: &HashMap<&str, Vec<&str>>, path: String, paths: &mu
 fn paths(nodes: &HashMap<&str, Vec<&str>>) -> usize {
     let mut paths = Vec::new();
     search("start", nodes, "start".to_string(), &mut paths);
-    //dbg!(&paths);
     paths.len()
 }
 
@@ -54,13 +53,72 @@ fn part1(input: &str) -> Result<usize> {
     Ok(paths(&nodes))
 }
 
-/*
+fn search2<'a>(
-#[aoc(day12, part2)]
+    node: &str,
-fn part2(input: &[u64]) -> Result<u64> {
+    nodes: &HashMap<&'a str, Vec<&'a str>>,
-todo!("part2");
+    path: &[&'a str],
-Ok(0)
+    paths: &mut Vec<Vec<&'a str>>,
+    double: &'a str,
+    smalls: &[&'a str],
+) {
+    if node == "end" {
+        paths.push(path.to_vec());
+        return;
+    }
+    for neighbor in &nodes[node] {
+        // If lowercase.
+        if neighbor.as_bytes()[0] & 0x20 != 0 {
+            if neighbor == &double {
+                // Allow two passes for this small node.
+                if path.iter().filter(|p| p == &neighbor).count() >= 2 {
+                    continue;
+                }
+            } else {
+                // Only allow one pass for this small node.
+                if path.contains(neighbor) {
+                    continue;
+                }
+            }
+        }
+        let mut child_path = path.to_vec();
+        child_path.push(neighbor);
+        search2(neighbor, nodes, &child_path, paths, double, smalls);
+    }
+}
+fn paths2(nodes: &HashMap<&str, Vec<&str>>) -> usize {
+    let mut paths = Vec::new();
+    let smalls: Vec<_> = nodes
+        .keys()
+        .filter(|n| n.as_bytes()[0] & 0x20 != 0)
+        .filter(|&n| n != &"start" && n != &"end")
+        .cloned()
+        .collect();
+
+    for double in &smalls {
+        search2(
+            "start",
+            nodes,
+            &vec!["start"],
+            &mut paths,
+            double,
+            smalls.as_slice(),
+        );
+    }
+    paths.sort();
+    paths.dedup();
+    paths.len()
+}
+
+#[aoc(day12, part2)]
+fn part2(input: &str) -> Result<usize> {
+    let mut nodes = HashMap::new();
+    input.lines().for_each(|p| {
+        let (n1, n2) = p.split_once('-').expect("missing dash");
+        nodes.entry(n1).or_insert(Vec::new()).push(n2);
+        nodes.entry(n2).or_insert(Vec::new()).push(n1);
+    });
+    Ok(paths2(&nodes))
 }
-*/
 
 #[cfg(test)]
 mod tests {
@@ -83,14 +141,19 @@ b-end
         Ok(())
     }
 
-    /*
     #[test]
-    fn test_part2()->Result<()> {
+    fn test_part2() -> Result<()> {
-    let input = r#"
+        let input = r#"
+start-A
+start-b
+A-c
+A-b
+b-d
+A-end
+b-end
     "#
-    .trim();
+        .trim();
-    assert_eq!(part2(&parse(input)?)?, u64::MAX);
+        assert_eq!(part2(input)?, 36);
-    Ok(())
+        Ok(())
     }
-    */
 }