Add Lee Algorithm (#583)

Author: mohit07raghav19

src/graph/lee.rs

@@ -0,0 +1,117 @@
+use std::collections::VecDeque;
+
+// All four potential movements from a cell are listed here.
+
+fn validate(matrix: &[Vec<i32>], visited: &[Vec<bool>], row: isize, col: isize) -> bool {
+    // Check if it is possible to move to the position (row, col) from the current cell.
+    let (row, col) = (row as usize, col as usize);
+    row < matrix.len() && col < matrix[0].len() && matrix[row][col] == 1 && !visited[row][col]
+}
+
+pub fn lee(matrix: Vec<Vec<i32>>, source: (usize, usize), destination: (usize, usize)) -> isize {
+    const ROW: [isize; 4] = [-1, 0, 0, 1];
+    const COL: [isize; 4] = [0, -1, 1, 0];
+    let (i, j) = source;
+    let (x, y) = destination;
+
+    // Base case: invalid input
+    if matrix.is_empty() || matrix[i][j] == 0 || matrix[x][y] == 0 {
+        return -1;
+    }
+
+    let (m, n) = (matrix.len(), matrix[0].len());
+    let mut visited = vec![vec![false; n]; m];
+    let mut q = VecDeque::new();
+    visited[i][j] = true;
+    q.push_back((i, j, 0));
+    let mut min_dist = isize::MAX;
+
+    // Loop until the queue is empty
+    while let Some((i, j, dist)) = q.pop_front() {
+        if i == x && j == y {
+            // If the destination is found, update `min_dist` and stop
+            min_dist = dist;
+            break;
+        }
+
+        // Check for all four possible movements from the current cell
+        for k in 0..ROW.len() {
+            let row = i as isize + ROW[k];
+            let col = j as isize + COL[k];
+            if validate(&matrix, &visited, row, col) {
+                // Mark the next cell as visited and enqueue it
+                let (row, col) = (row as usize, col as usize);
+                visited[row][col] = true;
+                q.push_back((row, col, dist + 1));
+            }
+        }
+    }
+
+    if min_dist != isize::MAX {
+        min_dist
+    } else {
+        -1
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_lee_exists() {
+        let mat: Vec<Vec<i32>> = vec![
+            vec![1, 0, 1, 1, 1],
+            vec![1, 0, 1, 0, 1],
+            vec![1, 1, 1, 0, 1],
+            vec![0, 0, 0, 0, 1],
+            vec![1, 1, 1, 0, 1],
+        ];
+        let source = (0, 0);
+        let dest = (2, 1);
+        assert_eq!(lee(mat, source, dest), 3);
+    }
+
+    #[test]
+    fn test_lee_does_not_exist() {
+        let mat: Vec<Vec<i32>> = vec![
+            vec![1, 0, 1, 1, 1],
+            vec![1, 0, 0, 0, 1],
+            vec![1, 1, 1, 0, 1],
+            vec![0, 0, 0, 0, 1],
+            vec![1, 1, 1, 0, 1],
+        ];
+        let source = (0, 0);
+        let dest = (3, 4);
+        assert_eq!(lee(mat, source, dest), -1);
+    }
+
+    #[test]
+    fn test_source_equals_destination() {
+        let mat: Vec<Vec<i32>> = vec![
+            vec![1, 0, 1, 1, 1],
+            vec![1, 0, 1, 0, 1],
+            vec![1, 1, 1, 0, 1],
+            vec![0, 0, 0, 0, 1],
+            vec![1, 1, 1, 0, 1],
+        ];
+        let source = (2, 1);
+        let dest = (2, 1);
+        assert_eq!(lee(mat, source, dest), 0);
+    }
+
+    #[test]
+    fn test_lee_exists_2() {
+        let mat: Vec<Vec<i32>> = vec![
+            vec![1, 1, 1, 1, 1, 0, 0],
+            vec![1, 1, 1, 1, 1, 1, 0],
+            vec![1, 0, 1, 0, 1, 1, 1],
+            vec![1, 1, 1, 1, 1, 0, 1],
+            vec![0, 0, 0, 1, 0, 0, 0],
+            vec![1, 0, 1, 1, 1, 0, 0],
+            vec![0, 0, 0, 0, 1, 0, 0],
+        ];
+        let source = (0, 0);
+        let dest = (3, 2);
+        assert_eq!(lee(mat, source, dest), 5);
+    }
+}

src/graph/mod.rs

@@ -14,6 +14,7 @@ mod ford_fulkerson;
 mod graph_enumeration;
 mod heavy_light_decomposition;
 mod kosaraju;
+mod lee;
 mod lowest_common_ancestor;
 mod minimum_spanning_tree;
 mod prim;
@@ -39,6 +40,7 @@ pub use self::ford_fulkerson::ford_fulkerson;
 pub use self::graph_enumeration::enumerate_graph;
 pub use self::heavy_light_decomposition::HeavyLightDecomposition;
 pub use self::kosaraju::kosaraju;
+pub use self::lee::lee;
 pub use self::lowest_common_ancestor::{LowestCommonAncestorOffline, LowestCommonAncestorOnline};
 pub use self::minimum_spanning_tree::kruskal;
 pub use self::prim::{prim, prim_with_start};