bridges (#63)

* bridges

* finish docs

* nit

* have self edge in example

* nit

---------

Co-authored-by: Luke Videckis <lukevideckis@gmail.com>

Author: lrvideckis

Cargo.toml

@@ -134,6 +134,14 @@ path = "examples/graphs/hld_jump_on_tree_nodes.rs"
 name = "hld_jump_on_tree_edges"
 path = "examples/graphs/hld_jump_on_tree_edges.rs"
 
+[[example]]
+name = "bridges_yosupo"
+path = "examples/graphs/bridges_yosupo.rs"
+
+[[example]]
+name = "bridges_aizu"
+path = "examples/graphs/bridges_aizu.rs"
+
 [[example]]
 name = "ext_gcd"
 path = "examples/numbers/ext_gcd.rs"

examples/graphs/bridges_aizu.rs

@@ -0,0 +1,39 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/GRL_3_B
+
+use proconio::input;
+use programming_team_code_rust::graphs::bridges::get_bridges;
+
+fn main() {
+    input! {
+        n: usize,
+        m: usize,
+        mut edges: [(usize, usize); m],
+    }
+
+    let mut adj = vec![vec![]; n];
+    for (i, &(u, v)) in edges.iter().enumerate() {
+        adj[u].push((v, i));
+        adj[v].push((u, i));
+    }
+
+    let (_, is_bridge, two_edge_ccid) = get_bridges(&adj, m);
+
+    for (i, &(u, v)) in edges.iter().enumerate() {
+        assert_eq!(is_bridge[i], two_edge_ccid[u] != two_edge_ccid[v]);
+    }
+
+    let mut all_bridges: Vec<(usize, usize)> = vec![];
+
+    for (i, (mut u, mut v)) in edges.iter_mut().enumerate() {
+        if is_bridge[i] {
+            if u > v {
+                std::mem::swap(&mut u, &mut v);
+            }
+            all_bridges.push((u, v));
+        }
+    }
+    all_bridges.sort();
+    for (u, v) in all_bridges {
+        println!("{} {}", u, v);
+    }
+}

examples/graphs/bridges_yosupo.rs

@@ -0,0 +1,39 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/two_edge_connected_components
+
+use proconio::input;
+use programming_team_code_rust::graphs::bridges::get_bridges;
+
+fn main() {
+    input! {
+        n: usize,
+        m: usize,
+        edges: [(usize, usize); m],
+    }
+
+    let mut adj = vec![vec![]; n];
+    for (i, &(u, v)) in edges.iter().enumerate() {
+        adj[u].push((v, i));
+        adj[v].push((u, i));
+    }
+
+    let (num_2_edge_ccs, is_bridge, two_edge_ccid) = get_bridges(&adj, m);
+
+    for (i, &(u, v)) in edges.iter().enumerate() {
+        assert_eq!(is_bridge[i], two_edge_ccid[u] != two_edge_ccid[v]);
+    }
+
+    println!("{}", num_2_edge_ccs);
+
+    let mut bridge_ccs = vec![vec![]; num_2_edge_ccs];
+    for i in 0..n {
+        bridge_ccs[two_edge_ccid[i]].push(i);
+    }
+
+    for cc in bridge_ccs.iter() {
+        print!("{} ", cc.len());
+        for u in cc {
+            print!("{} ", u);
+        }
+        println!();
+    }
+}

src/graphs/bridges.rs

@@ -0,0 +1,93 @@
+//! # Bridge Edges
+
+/// # Guarantees
+/// - 0 <= two_edge_ccid\[u\] < num_2_edge_ccs
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::graphs::bridges::get_bridges;
+///
+/// let edge_list = [(0,1), (0,1), (1,2), (2,2)];
+/// let mut adj = vec![vec![]; 3];
+/// for (i, &(u, v)) in edge_list.iter().enumerate() {
+///    adj[u].push((v, i));
+///    adj[v].push((u, i));
+/// }
+///
+/// let (num_2_edge_ccs, is_bridge, two_edge_ccid) = get_bridges(&adj, 4);
+///
+/// assert_eq!(num_2_edge_ccs, 2);
+/// assert_eq!(is_bridge, vec![false, false, true, false]);
+/// assert_eq!(two_edge_ccid, vec![1, 1, 0]);
+/// ```
+///
+/// # Complexity
+/// - Time: O(V + E)
+/// - Space: O(V)
+pub fn get_bridges(adj: &[Vec<(usize, usize)>], m: usize) -> (usize, Vec<bool>, Vec<usize>) {
+    #[allow(clippy::too_many_arguments)]
+    fn dfs(
+        u: usize,
+        p_id: Option<usize>,
+        adj: &[Vec<(usize, usize)>],
+        timer: &mut usize,
+        tin: &mut [usize],
+        num_2_edge_ccs: &mut usize,
+        is_bridge: &mut [bool],
+        two_edge_ccid: &mut [usize],
+        st: &mut Vec<usize>,
+    ) -> usize {
+        tin[u] = *timer;
+        let (mut low, st_sz) = (*timer, st.len());
+        *timer += 1;
+        st.push(u);
+        for &(v, e_id) in &adj[u] {
+            if Some(e_id) == p_id {
+                continue;
+            }
+            if tin[v] == 0 {
+                low = low.min(dfs(
+                    v,
+                    Some(e_id),
+                    adj,
+                    timer,
+                    tin,
+                    num_2_edge_ccs,
+                    is_bridge,
+                    two_edge_ccid,
+                    st,
+                ));
+            }
+            low = low.min(tin[v]);
+        }
+        if tin[u] == low {
+            if let Some(p) = p_id {
+                is_bridge[p] = true;
+            }
+            for &id in st.iter().skip(st_sz) {
+                two_edge_ccid[id] = *num_2_edge_ccs;
+            }
+            st.truncate(st_sz);
+            *num_2_edge_ccs += 1;
+        }
+        low
+    }
+    let (n, mut timer, mut num_2_edge_ccs, mut is_bridge) = (adj.len(), 1, 0, vec![false; m]);
+    let (mut tin, mut two_edge_ccid, mut st) = (vec![0; n], vec![0; n], Vec::with_capacity(n));
+    for i in 0..n {
+        if tin[i] == 0 {
+            dfs(
+                i,
+                None,
+                adj,
+                &mut timer,
+                &mut tin,
+                &mut num_2_edge_ccs,
+                &mut is_bridge,
+                &mut two_edge_ccid,
+                &mut st,
+            );
+        }
+    }
+    (num_2_edge_ccs, is_bridge, two_edge_ccid)
+}

src/graphs/mod.rs

@@ -1,4 +1,5 @@
 //! # Graph Algorithms
+pub mod bridges;
 pub mod cent_decomp;
 pub mod count_paths_per_length;
 mod dfs_order;