day12 part1

day12/src/main.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::{HashSet, VecDeque};
 
 fn main() {
     let input = std::fs::read_to_string("input").unwrap();
@@ -7,54 +7,45 @@ fn main() {
 }
 
 fn pt1(grid: &Garden) -> usize {
+    let mut visited = HashSet::new();
     let mut cost = 0;
-    let regions = regions(grid);
-    println!("there are {} regions", regions.len());
-    for (_root, region) in regions {
-        let a = region.len();
-        let mut p = 0;
-        for plot in region {
-            p += plot.p_val;
-        }
-        cost += a * p;
-    }
-
-    cost
-}
-
-fn regions(grid: &Garden) -> Regions {
-    let mut out = Regions::new();
-    let mut knowns = HashSet::new();
-
     for row in grid.rows.iter() {
         for plot in row.iter() {
             let root = plot.loc;
-            let mut q = VecDeque::new();
+            if visited.contains(&root) {
-            if !knowns.contains(&root) {
-                q.push_back(root);
-            } else {
                 continue;
             }
+            let mut q = VecDeque::new();
+            q.push_back(root);
             let mut region = HashSet::new();
+            let mut visiting = HashSet::new();
             while let Some(current) = q.pop_front() {
-                knowns.insert(current);
+                visited.insert(current);
+                visiting.remove(&current);
                 let nexts = grid.neighbors(&current);
                 for next in nexts
                     .iter()
                     .map(|n| grid.get(n).unwrap())
                     .filter(|n| !region.contains(n))
                 {
-                    q.push_back(next.loc);
+                    if !visiting.contains(&next.loc) {
+                        q.push_back(next.loc);
+                        visiting.insert(next.loc);
+                    }
                 }
                 region.insert(grid.get(&current).unwrap());
             }
-            let _ = out.entry(root).or_insert(region);
+            let a = region.len();
+            let mut p = 0;
+            for plot in region {
+                p += plot.p_val;
+            }
+            cost += a * p;
         }
     }
-    out
-}
 
-type Regions<'g> = HashMap<Loc, HashSet<&'g Plot>>;
+    cost
+}
 
 #[derive(Debug, Clone)]
 struct Garden {
@@ -82,14 +73,11 @@ impl Garden {
         let cols = g.rows[0].len();
         for row in 0..rows {
             for col in 0..cols {
-                let mut plot = g.rows[row][col];
                 let mut p = 4;
-                let loc = plot.loc;
+                for _ in g.neighbors(&Loc { row, col }) {
-                for _ in g.neighbors(&loc) {
                     p -= 1;
                 }
-                plot.p_val = p;
+                g.rows[row][col].p_val = p;
-                g.rows[row][col] = plot;
             }
         }
         g