Cuts (#64)

* saving progress

* now ACs

* nits

* finish

* start of docs

* add docs

* better style

* nit

---------

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

Author: lrvideckis

.gitignore

@@ -3,3 +3,4 @@ Cargo.lock
 .verify-helper/
 default_*.profraw
 ptc_rust.profdata
+input

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 = "cuts_yosupo"
+path = "examples/graphs/cuts_yosupo.rs"
+
+[[example]]
+name = "cuts_aizu"
+path = "examples/graphs/cuts_aizu.rs"
+
 [[example]]
 name = "bridges_yosupo"
 path = "examples/graphs/bridges_yosupo.rs"

examples/graphs/cuts_aizu.rs

@@ -0,0 +1,40 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/GRL_3_A
+
+use proconio::input;
+use programming_team_code_rust::graphs::cuts::get_cuts;
+
+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 (_, is_cut, bcc_id) = get_cuts(&adj, m);
+
+    for i in 0..n {
+        assert_eq!(
+            is_cut[i],
+            adj[i]
+                .iter()
+                .any(|&(_, e_id)| bcc_id[e_id] != bcc_id[adj[i][0].1])
+        );
+    }
+
+    let all_cut_nodes = is_cut
+        .iter()
+        .enumerate()
+        .filter(|(_, &value)| value)
+        .map(|(index, _)| index)
+        .collect::<Vec<usize>>();
+
+    for u in all_cut_nodes {
+        println!("{}", u);
+    }
+}

examples/graphs/cuts_yosupo.rs

@@ -0,0 +1,53 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/biconnected_components
+
+use proconio::input;
+use programming_team_code_rust::graphs::block_vertex_tree::get_bvt;
+use programming_team_code_rust::graphs::cuts::get_cuts;
+
+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_bccs, is_cut, bcc_id) = get_cuts(&adj, m);
+    let bvt = get_bvt(&adj, num_bccs, &bcc_id);
+
+    for i in 0..n {
+        assert_eq!(
+            is_cut[i],
+            adj[i]
+                .iter()
+                .any(|&(_, e_id)| bcc_id[e_id] != bcc_id[adj[i][0].1])
+        );
+        assert_eq!(is_cut[i], bvt[i].len() >= 2);
+    }
+
+    let lone_nodes = adj
+        .iter()
+        .enumerate()
+        .filter(|&(_, neighbors)| neighbors.is_empty())
+        .map(|(i, _)| i)
+        .collect::<Vec<usize>>();
+
+    println!("{}", num_bccs + lone_nodes.len());
+
+    for u in lone_nodes {
+        println!("1 {}", u);
+    }
+
+    for neighbors in bvt.iter().skip(n) {
+        print!("{} ", neighbors.len());
+        for u in neighbors {
+            print!("{} ", u);
+        }
+        println!();
+    }
+}

src/graphs/block_vertex_tree.rs

@@ -0,0 +1,60 @@
+//! # Block Vertex Tree
+
+/// # Guarantees
+/// - 0 <= bcc_id\[u\] < num_bccs
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::graphs::cuts::get_cuts;
+/// use programming_team_code_rust::graphs::block_vertex_tree::get_bvt;
+///
+/// let edge_list = [(0,1), (0,1), (1,2), (0,1)];
+/// let (n, m) = (3, 4);
+/// let mut adj = vec![vec![]; n];
+/// for (i, &(u, v)) in edge_list.iter().enumerate() {
+///    adj[u].push((v, i));
+///    adj[v].push((u, i));
+/// }
+///
+/// let (num_bccs, _, bcc_id) = get_cuts(&adj, m);
+/// let bvt = get_bvt(&adj, num_bccs, &bcc_id);
+///
+/// assert_eq!(bvt, [vec![4], vec![4, 3], vec![3], vec![1, 2], vec![0, 1]]);
+///
+/// // indexes 0..n are nodes
+/// // indexes n..n + num_bccs are bccs
+///
+/// for u in 0..n {
+///    // loop over each unique bcc containing a node u
+///    for bccid in bvt[u].iter().map(|v| v - n) {
+///       assert!(0 <= bccid && bccid < num_bccs);
+///    }
+/// }
+/// for bccid in 0..num_bccs {
+///     // loop over each unique node inside a bcc
+///    for &u in bvt[bccid + n].iter() {
+///       assert!(0 <= u && u < n);
+///    }
+/// }
+/// ```
+///
+/// # Complexity
+/// - Time: O(V + E)
+/// - Space: O(V)
+pub fn get_bvt(adj: &[Vec<(usize, usize)>], num_bccs: usize, bcc_id: &[usize]) -> Vec<Vec<usize>> {
+    let (n, mut vis) = (adj.len(), vec![false; num_bccs]);
+    let mut bvt = vec![vec![]; n + num_bccs];
+    for i in 0..n {
+        for id in adj[i].iter().map(|&(_, e_id)| bcc_id[e_id]) {
+            if !vis[id] {
+                vis[id] = true;
+                bvt[i].push(id + n);
+                bvt[id + n].push(i);
+            }
+        }
+        for id in bvt[i].iter().map(|v| v - n) {
+            vis[id] = false;
+        }
+    }
+    bvt
+}

src/graphs/cuts.rs

@@ -0,0 +1,103 @@
+//! # Cut nodes
+
+/// # Guarantees
+/// - 0 <= bcc_id\[u\] < num_bccs
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::graphs::cuts::get_cuts;
+///
+/// let edge_list = [(0,1), (0,1), (1,2), (0,1)];
+/// 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_bccs, is_cut, bcc_id) = get_cuts(&adj, 4);
+///
+/// assert_eq!(num_bccs, 2);
+/// assert_eq!(is_cut, vec![false, true, false]);
+/// assert_eq!(bcc_id, vec![1, 1, 0, 1]);
+/// ```
+///
+/// # Panics
+/// ```panic
+/// use programming_team_code_rust::graphs::cuts::get_cuts;
+/// let edge_list = [(0,0)];
+/// let mut adj = vec![vec![]; 1];
+/// for (i, &(u, v)) in edge_list.iter().enumerate() {
+///    adj[u].push((v, i));
+///    adj[v].push((u, i));
+/// }
+/// let (_, _, _) = get_cuts(&adj, 1);
+/// ```
+///
+/// # Complexity
+/// - Time: O(V + E)
+/// - Space: O(V)
+pub fn get_cuts(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_bccs: &mut usize,
+        is_cut: &mut [bool],
+        bcc_id: &mut [usize],
+        st: &mut Vec<usize>,
+    ) -> usize {
+        tin[u] = *timer;
+        let (mut low, mut deg) = (*timer, 0);
+        *timer += 1;
+        for &(v, e_id) in &adj[u] {
+            assert_ne!(u, v);
+            if Some(e_id) == p_id {
+                continue;
+            }
+            if tin[v] == 0 {
+                let st_sz = st.len();
+                st.push(e_id);
+                let low_ch = dfs(v, Some(e_id), adj, timer, tin, num_bccs, is_cut, bcc_id, st);
+                if low_ch >= tin[u] {
+                    is_cut[u] = true;
+                    for &id in st.iter().skip(st_sz) {
+                        bcc_id[id] = *num_bccs;
+                    }
+                    st.truncate(st_sz);
+                    *num_bccs += 1;
+                }
+                low = low.min(low_ch);
+                deg += 1;
+            } else if tin[v] < tin[u] {
+                st.push(e_id);
+                low = low.min(tin[v]);
+            }
+        }
+        if p_id.is_none() {
+            is_cut[u] = deg > 1;
+        }
+        low
+    }
+    let (n, mut timer, mut num_bccs, mut bcc_id, mut st) =
+        (adj.len(), 1, 0, vec![0; m], Vec::with_capacity(m));
+    let (mut tin, mut is_cut) = (vec![0; n], vec![false; n]);
+    for i in 0..n {
+        if tin[i] == 0 {
+            dfs(
+                i,
+                None,
+                adj,
+                &mut timer,
+                &mut tin,
+                &mut num_bccs,
+                &mut is_cut,
+                &mut bcc_id,
+                &mut st,
+            );
+        }
+    }
+    (num_bccs, is_cut, bcc_id)
+}

src/graphs/mod.rs

@@ -1,7 +1,9 @@
 //! # Graph Algorithms
+pub mod block_vertex_tree;
 pub mod bridges;
 pub mod cent_decomp;
 pub mod count_paths_per_length;
+pub mod cuts;
 mod dfs_order;
 pub mod dijk;
 pub mod hld;