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,10 +7,34 @@ fn main() {
 }
 
 fn pt1(grid: &Garden) -> usize {
+    let mut visited = HashSet::new();
     let mut cost = 0;
-    let regions = regions(grid);
+    for row in grid.rows.iter() {
-    println!("there are {} regions", regions.len());
+        for plot in row.iter() {
-    for (_root, region) in regions {
+            let root = plot.loc;
+            if visited.contains(&root) {
+                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() {
+                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))
+                {
+                    if !visiting.contains(&next.loc) {
+                        q.push_back(next.loc);
+                        visiting.insert(next.loc);
+                    }
+                }
+                region.insert(grid.get(&current).unwrap());
+            }
             let a = region.len();
             let mut p = 0;
             for plot in region {
@@ -18,44 +42,11 @@ fn pt1(grid: &Garden) -> usize {
             }
             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 !knowns.contains(&root) {
-                q.push_back(root);
-            } else {
-                continue;
-            }
-            let mut region = HashSet::new();
-            while let Some(current) = q.pop_front() {
-                knowns.insert(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);
-                }
-                region.insert(grid.get(&current).unwrap());
-            }
-            let _ = out.entry(root).or_insert(region);
-        }
-    }
-    out
-}
-
-type Regions<'g> = HashMap<Loc, HashSet<&'g Plot>>;
-
 #[derive(Debug, Clone)]
 struct Garden {
     rows: Vec<Vec<Plot>>,
@@ -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