Broken code, while I try to understand ownership, borrowing and lifetimes :(

Author: Xophmeister

12/src/error.rs

@@ -1,10 +1,13 @@
 use std::fmt;
 use std::io;
 
+use crate::map::Coord;
+
 #[derive(Debug)]
 pub enum Error {
     IOError(String),
     ParseError,
+    NoRoute(Coord, Coord),
 }
 
 impl std::error::Error for Error {}
@@ -14,6 +17,7 @@ impl fmt::Display for Error {
         match self {
             Self::IOError(reason) => write!(f, "IO error: {reason}"),
             Self::ParseError => write!(f, "Parse error: Couldn't parse input"),
+            Self::NoRoute(start, finish) => write!(f, "No route found from {start} to {finish}"),
         }
     }
 }

12/src/lib.rs

@@ -1,5 +1,7 @@
 mod error;
 mod map;
+mod route;
 
 pub use crate::error::Error;
 pub use crate::map::Map;
+pub use crate::route::Route;

12/src/main.rs

@@ -1,4 +1,4 @@
-use aoc22_12::{Error, Map};
+use aoc22_12::{Error, Map, Route};
 
 fn main() {
     if let Err(e) = run() {
@@ -10,7 +10,8 @@ fn main() {
 fn run() -> Result<(), Error> {
     let map = Map::parse()?;
 
-    //println!("{} x {}", map.size().x(), map.size().y());
+    let route = Route::try_from(&map)?;
+    println!("Part 1: {}", route.len());
 
     Ok(())
 }

12/src/map.rs

@@ -1,3 +1,4 @@
+use std::fmt;
 use std::io::stdin;
 use std::ops::Sub;
 
@@ -8,7 +9,7 @@ pub struct Elevation(u8);
 
 impl From<char> for Elevation {
     fn from(input: char) -> Self {
-        Elevation(input as u8 - b'a')
+        Self(input as u8 - b'a')
     }
 }
 
@@ -28,23 +29,22 @@ impl Sub for Elevation {
     }
 }
 
-#[derive(Clone, Copy)]
-pub struct Coord(usize, usize);
-
-impl Coord {
-    pub fn x(self) -> usize {
-        self.0
-    }
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Coord {
+    pub x: usize,
+    pub y: usize,
+}
 
-    pub fn y(self) -> usize {
-        self.1
+impl fmt::Display for Coord {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
     }
 }
 
 pub struct Map {
     field: (Vec<Elevation>, usize, usize),
     pub start: Coord,
-    pub end: Coord,
+    pub finish: Coord,
 }
 
 impl Map {
@@ -74,12 +74,12 @@ impl Map {
 
                     'S' => {
                         field.push('a'.into());
-                        start = Some(Coord(x, y));
+                        start = Some(Coord { x, y });
                     }
 
                     'E' => {
                         field.push('z'.into());
-                        end = Some(Coord(x, y));
+                        end = Some(Coord { x, y });
                     }
 
                     _ => return Err(Error::ParseError),
@@ -90,22 +90,22 @@ impl Map {
             line.clear();
         }
 
-        Ok(Map {
+        Ok(Self {
             field: (field, width.ok_or(Error::ParseError)?, y),
             start: start.ok_or(Error::ParseError)?,
-            end: end.ok_or(Error::ParseError)?,
+            finish: end.ok_or(Error::ParseError)?,
         })
     }
 
     pub fn size(&self) -> Coord {
-        let (_, width, height) = self.field;
-        Coord(width, height)
+        let (_, x, y) = self.field;
+        Coord { x, y }
     }
 
     pub fn elevation(&self, at: Coord) -> Elevation {
         let (field, width, height) = &self.field;
-        assert!(at.x() < *width && at.y() < *height);
+        assert!(at.x < *width && at.y < *height);
 
-        field[at.x() + (at.y() * width)]
+        field[at.x + (at.y * width)]
     }
 }

12/src/route.rs

@@ -0,0 +1,94 @@
+use std::collections::VecDeque;
+
+use crate::error::Error;
+use crate::map::{Coord, Map};
+
+struct LocationNode<'a> {
+    parent: Option<&'a LocationNode<'a>>,
+    coord: Coord,
+}
+
+// FIXME
+impl Iterator for LocationNode<'_> {
+    type Item<'a> = LocationNode<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.parent
+    }
+}
+
+pub struct Route(Vec<Coord>);
+
+impl TryFrom<&Map> for Route {
+    type Error = Error;
+
+    fn try_from(map: &Map) -> Result<Self, Self::Error> {
+        let width = map.size().x as isize;
+        let height = map.size().y as isize;
+
+        // Maintain a tree of visited locations
+        let mut tree: Vec<LocationNode> = vec![LocationNode {
+            parent: None,
+            coord: map.start,
+        }];
+
+        // Maintain a queue of locations from which to explore, starting with the root
+        let mut to_explore: VecDeque<&LocationNode> = VecDeque::from([&tree[0]]);
+
+        // Breadth-first search that builds up the tree until it reaches the finish
+        while let Some(location) = to_explore.pop_front() {
+            if location.coord == map.finish {
+                // Iterate up to the root (i.e., start) and reverse to obtain the route
+                let route = Vec::from_iter(*location.iter().rev().map(|location| location.coord));
+                return Ok(Route(route));
+            }
+
+            // Find assailable locations (besides where we just came from) and add enqueue
+            let previous = location.parent;
+            for delta_x in [-1, 1] {
+                for delta_y in [-1, 1] {
+                    // Short-circuit the loop if potential locations fall off the edges of the map
+                    let new_x = location.coord.x as isize + delta_x;
+                    let new_y = location.coord.y as isize + delta_y;
+                    if new_x < 0 || new_x >= width || new_y < 0 || new_y >= height {
+                        continue;
+                    }
+
+                    let potential = Coord {
+                        x: new_x as usize,
+                        y: new_y as usize,
+                    };
+
+                    // Short-circuit the loop if we've just come from a potential location
+                    if previous.is_some() && previous.unwrap().coord == potential {
+                        continue;
+                    }
+
+                    // Add assailable locations to the tree and enqueue to explore
+                    if (map.elevation(location.coord) - map.elevation(potential)).assailable() {
+                        // FIXME
+                        tree.push(LocationNode {
+                            parent: Some(location),
+                            coord: potential,
+                        });
+
+                        to_explore.push_back(tree.last().unwrap())
+                    }
+                }
+            }
+        }
+
+        // No route found
+        Err(Error::NoRoute(map.start, map.finish))
+    }
+}
+
+impl Route {
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}