minor lca changes and dfs order changes (#32)

* working on scc

* scc too hard

Author: cameroncuster

examples/graphs/lca_yosupo.rs

@@ -9,35 +9,39 @@ fn main() {
         q: usize,
     }
 
-    // undirected tree and a rooted directed tree
-    let mut undir = vec![vec![]; n + n];
+    // undirected forest and a rooted directed tree
+    let mut undir_for = vec![vec![]; n + n];
     let mut dir = vec![vec![]; n];
     for c in 1..n {
         input! {
             p: usize,
         }
 
-        // undirected tree
-        undir[p].push(c);
-        undir[c].push(p);
+        // undirected forest
+        for &(u, v) in [(p, c), (p + n, c + n)].iter() {
+            undir_for[u].push(v);
+            undir_for[v].push(u);
+        }
 
         // directed tree
         dir[p].push(c);
     }
 
-    let undir_lca = LCA::new(&undir);
+    let undir_lca = LCA::new(&undir_for);
     let dir_lca = LCA::new(&dir);
     for _ in 0..q {
         input! {
             u: usize,
             v: usize,
         }
 
-        let res_undir = undir_lca.lca(u, v);
+        let res_undir1 = undir_lca.lca(u, v);
+        let res_undir2 = undir_lca.lca(u + n, v + n) - n;
         let res_dir = dir_lca.lca(u, v);
 
-        assert_eq!(res_undir, res_dir);
+        assert_eq!(res_undir1, res_undir2);
+        assert_eq!(res_undir1, res_dir);
 
-        println!("{}", res_undir);
+        println!("{}", res_dir);
     }
 }

src/graphs/dfs_order.rs

@@ -1,14 +1,20 @@
 pub fn dfs_order(adj: &[Vec<usize>]) -> Vec<usize> {
     let n = adj.len();
-    let mut order = Vec::with_capacity(n);
-    fn dfs(u: usize, p: usize, adj: &[Vec<usize>], order: &mut Vec<usize>) {
+    fn dfs(u: usize, adj: &[Vec<usize>], seen: &mut [bool], order: &mut Vec<usize>) {
         order.push(u);
+        seen[u] = true;
         for &v in &adj[u] {
-            if v != p {
-                dfs(v, u, adj, order);
+            if !seen[v] {
+                dfs(v, adj, seen, order);
             }
         }
     }
-    dfs(0, 0, adj, &mut order);
+    let mut seen = vec![false; n];
+    let mut order = Vec::with_capacity(n);
+    for s in 0..n {
+        if !seen[s] {
+            dfs(s, adj, &mut seen, &mut order);
+        }
+    }
     order
 }

src/graphs/lca.rs

@@ -32,6 +32,7 @@ impl LCA {
     /// Create a new LCA struct
     ///
     /// `adj` can be undirected tree or a directed tree (rooted at node 0)
+    /// `adj` can also be an undirected forest
     ///
     /// # Complexity (n = adj.len())
     /// - Time: O(n log n)