add sccs (#40)

* add sccs

* fix clippy

* fix cargo doc

Author: cameroncuster

Cargo.toml

@@ -66,6 +66,10 @@ path = "examples/graphs/lca_aizu.rs"
 name = "lca_yosupo"
 path = "examples/graphs/lca_yosupo.rs"
 
+[[example]]
+name = "scc"
+path = "examples/graphs/scc.rs"
+
 [[example]]
 name = "binom"
 path = "examples/numbers/binom.rs"

examples/graphs/scc.rs

@@ -0,0 +1,33 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/scc
+
+use proconio::input;
+use programming_team_code_rust::graphs::scc::get_sccs;
+
+fn main() {
+    input! {
+        n: usize,
+        m: usize,
+        edges: [(usize, usize); m],
+    }
+
+    let mut adj = vec![vec![]; n];
+    for (u, v) in edges {
+        adj[u].push(v);
+    }
+
+    let (num_sccs, scc_id) = get_sccs(&adj);
+    println!("{}", num_sccs);
+
+    let mut sccs = vec![vec![]; num_sccs];
+    for i in 0..n {
+        sccs[scc_id[i]].push(i);
+    }
+
+    for scc in sccs {
+        print!("{}", scc.len());
+        for v in scc {
+            print!(" {}", v);
+        }
+        println!();
+    }
+}

src/graphs/dfs_order.rs

@@ -1,20 +1,42 @@
-pub fn dfs_order(adj: &[Vec<usize>]) -> Vec<usize> {
-    let n = adj.len();
-    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 !seen[v] {
-                dfs(v, adj, seen, order);
-            }
+fn dfs_preorder(u: usize, adj: &[Vec<usize>], seen: &mut [bool], order: &mut Vec<usize>) {
+    order.push(u);
+    seen[u] = true;
+    for &v in &adj[u] {
+        if !seen[v] {
+            dfs_preorder(v, adj, seen, order);
+        }
+    }
+}
+
+fn dfs_postorder(u: usize, adj: &[Vec<usize>], seen: &mut [bool], order: &mut Vec<usize>) {
+    seen[u] = true;
+    for &v in &adj[u] {
+        if !seen[v] {
+            dfs_postorder(v, adj, seen, order);
         }
     }
+    order.push(u);
+}
+
+fn get_dfs_order<F>(adj: &[Vec<usize>], dfs_order: F) -> Vec<usize>
+where
+    F: Fn(usize, &[Vec<usize>], &mut [bool], &mut Vec<usize>),
+{
+    let n = adj.len();
     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);
+            dfs_order(s, adj, &mut seen, &mut order);
         }
     }
     order
 }
+
+pub fn get_dfs_preorder(adj: &[Vec<usize>]) -> Vec<usize> {
+    get_dfs_order(adj, dfs_preorder)
+}
+
+pub fn get_dfs_postorder(adj: &[Vec<usize>]) -> Vec<usize> {
+    get_dfs_order(adj, dfs_postorder)
+}

src/graphs/lca.rs

@@ -1,7 +1,7 @@
 //! # Lowest Common Ancestor
 
 use crate::data_structures::rmq::RMQ;
-use crate::graphs::dfs_order::dfs_order;
+use crate::graphs::dfs_order::get_dfs_preorder;
 
 /// # Example
 /// ```
@@ -42,7 +42,7 @@ impl LCA {
         let mut tin = vec![0; n];
         let mut p = vec![0; n];
         let mut d = vec![0; n];
-        let order = dfs_order(adj);
+        let order = get_dfs_preorder(adj);
         for (i, &u) in order.iter().enumerate() {
             tin[u] = i;
             for &v in &adj[u] {

src/graphs/mod.rs

@@ -4,3 +4,4 @@ pub mod count_paths_per_length;
 mod dfs_order;
 pub mod dijk;
 pub mod lca;
+pub mod scc;

src/graphs/scc.rs

@@ -0,0 +1,64 @@
+//! # Strongly Connected Components
+
+use crate::graphs::dfs_order::get_dfs_postorder;
+
+fn dfs(u: usize, adj: &[Vec<usize>], seen: &mut [bool], scc_id: &mut [usize], num_sccs: usize) {
+    scc_id[u] = num_sccs;
+    seen[u] = true;
+    for &v in &adj[u] {
+        if !seen[v] {
+            dfs(v, adj, seen, scc_id, num_sccs);
+        }
+    }
+}
+
+/// # Guarantees
+/// - 0..num_sccs is a topological order of the SCCs
+/// - 0 <= scc_id\[u\] < num_sccs
+/// - for each edge u -> v: scc_id\[u\] <= scc_id\[v\]
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::graphs::scc::get_sccs;
+///
+/// let adj = vec![
+///    vec![1],
+///    vec![2],
+///    vec![0],
+///    vec![3],
+///    vec![5],
+///    vec![4],
+///    vec![5],
+/// ];
+///
+/// let (num_sccs, scc_id) = get_sccs(&adj);
+/// assert_eq!(num_sccs, 4);
+/// assert_eq!(scc_id, vec![3, 3, 3, 2, 1, 1, 0]);
+/// ```
+///
+/// # Complexity
+/// - Time: O(V + E)
+/// - Space: O(V)
+pub fn get_sccs(adj: &[Vec<usize>]) -> (usize, Vec<usize>) {
+    let n = adj.len();
+    let rv_adj = {
+        let mut rv_adj = vec![vec![]; n];
+        for (u, vs) in adj.iter().enumerate() {
+            for &v in vs {
+                rv_adj[v].push(u);
+            }
+        }
+        rv_adj
+    };
+    let order = get_dfs_postorder(adj);
+    let mut num_sccs = 0;
+    let mut scc_id = vec![0; n];
+    let mut seen = vec![false; n];
+    for &s in order.iter().rev() {
+        if !seen[s] {
+            dfs(s, &rv_adj, &mut seen, &mut scc_id, num_sccs);
+            num_sccs += 1;
+        }
+    }
+    (num_sccs, scc_id)
+}