nits (#68)

* nits

* another rename

* fix

* update some graph examples

* update more graph examples

---------

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

Author: lrvideckis

examples/graphs/cuts_yosupo.rs

@@ -1,7 +1,7 @@
 // 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::block_vertex_tree::get_block_vertex_tree;
 use programming_team_code_rust::graphs::cuts::get_cuts;
 
 fn main() {
@@ -18,7 +18,7 @@ fn main() {
     }
 
     let (num_bccs, is_cut, bcc_id) = get_cuts(&adj, m);
-    let bvt = get_bvt(&adj, num_bccs, &bcc_id);
+    let bvt = get_block_vertex_tree(&adj, num_bccs, &bcc_id);
 
     for i in 0..n {
         assert_eq!(

src/graphs/block_vertex_tree.rs

@@ -6,18 +6,17 @@
 /// # Example
 /// ```
 /// use programming_team_code_rust::graphs::cuts::get_cuts;
-/// use programming_team_code_rust::graphs::block_vertex_tree::get_bvt;
+/// use programming_team_code_rust::graphs::block_vertex_tree::get_block_vertex_tree;
 ///
-/// 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() {
+/// for (i, &(u, v)) in [(0,1), (0,1), (1,2), (0,1)].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);
+/// let bvt = get_block_vertex_tree(&adj, num_bccs, &bcc_id);
 ///
 /// assert_eq!(bvt, [vec![4], vec![4, 3], vec![3], vec![1, 2], vec![0, 1]]);
 ///
@@ -41,7 +40,11 @@
 /// # 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>> {
+pub fn get_block_vertex_tree(
+    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 {

src/graphs/bridges.rs

@@ -7,9 +7,8 @@
 /// ```
 /// 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() {
+/// for (i, &(u, v)) in [(0,1), (0,1), (1,2), (2,2)].iter().enumerate() {
 ///    adj[u].push((v, i));
 ///    adj[v].push((u, i));
 /// }

src/graphs/count_paths_per_length.rs

@@ -72,17 +72,15 @@ impl CentDecompDfs for CountPathsPerLength {
 /// # Example
 /// ```
 /// use programming_team_code_rust::graphs::count_paths_per_length::count_paths_per_length;
-/// let adj = vec![
-///    vec![1, 2],
-///    vec![0, 3, 4],
-///    vec![0, 5, 6],
-///    vec![1],
-///    vec![1],
-///    vec![2],
-///    vec![2],
-/// ];
+///
+/// let mut adj = vec![vec![]; 4];
+/// for (u, v) in [(0,1), (0,2), (0,3)] {
+///    adj[u].push(v);
+///    adj[v].push(u);
+/// }
+///
 /// let res = count_paths_per_length(&adj);
-/// assert_eq!(res, vec![0, 6, 7, 4, 4, 0, 0]);
+/// assert_eq!(res, [0, 3, 3, 0]);
 /// ```
 ///
 /// # Complexity

src/graphs/cuts.rs

@@ -7,9 +7,8 @@
 /// ```
 /// 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() {
+/// for (i, &(u, v)) in [(0,1), (0,1), (1,2), (0,1)].iter().enumerate() {
 ///    adj[u].push((v, i));
 ///    adj[v].push((u, i));
 /// }
@@ -24,9 +23,8 @@
 /// # 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() {
+/// for (i, &(u, v)) in [(0,0)].iter().enumerate() {
 ///    adj[u].push((v, i));
 ///    adj[v].push((u, i));
 /// }

src/graphs/hld.rs

@@ -8,22 +8,25 @@ use std::ops::Range;
 /// use programming_team_code_rust::graphs::hld::HLD;
 /// use programming_team_code_rust::data_structures::fenwick::Fenwick;
 ///
-/// let mut adj = vec![
-///    vec![1, 2],
-///    vec![0, 3, 4],
-///    vec![0, 5],
-///    vec![1],
-///    vec![1],
-///    vec![2],
-/// ];
-/// let fenwick = Fenwick::<usize>::build_on_array(&[3, 2, 4, 5, 1, 2]);
+/// let n = 4;
+/// let mut adj = vec![vec![]; n];
+/// for (u, v) in [(0,1), (0,2), (2,3)] {
+///    adj[u].push(v);
+///    adj[v].push(u);
+/// }
 ///
 /// let hld = HLD::new(&mut adj, false);
-/// assert_eq!(hld.lca(3, 4), 1);
-/// assert_eq!(fenwick.sum(hld.sub_tree(0)), 17);
+/// let mut fenwick = Fenwick::<usize>::new(n);
+/// let init_vals = [10, 1, 100, 1000];
+/// for i in 0..n {
+///    fenwick.add(hld.tin[i], init_vals[i]);
+/// }
+///
+/// assert_eq!(hld.lca(1, 3), 0);
+/// assert_eq!(fenwick.sum(hld.sub_tree(2)), 1100);
 /// let mut sum = 0;
-/// hld.path(3, 4, |range, _| sum += fenwick.sum(range));
-/// assert_eq!(sum, 11);
+/// hld.path(1, 2, |range, _| sum += fenwick.sum(range));
+/// assert_eq!(sum, 111);
 /// ```
 pub struct HLD {
     /// parent

src/graphs/lca.rs

@@ -9,24 +9,20 @@ type OpType = fn((usize, usize), (usize, usize)) -> (usize, usize);
 /// ```
 /// use programming_team_code_rust::graphs::lca::LCA;
 ///
-/// let adj = vec![
-///    vec![1, 2],
-///    vec![0, 3, 4],
-///    vec![0, 5],
-///    vec![1],
-///    vec![1],
-///    vec![2],
-/// ];
+/// let n = 4;
+/// let mut adj = vec![vec![]; n];
+/// for (u, v) in [(0,1), (0,2), (2,3)] {
+///    adj[u].push(v);
+///    adj[v].push(u);
+/// }
 ///
 /// let lca = LCA::new(&adj);
-/// assert_eq!(lca.lca(0, 1), 0);
-/// assert_eq!(lca.lca(0, 2), 0);
-/// assert_eq!(lca.lca(0, 5), 0);
-/// assert_eq!(lca.lca(3, 4), 1);
+/// assert_eq!(lca.lca(1, 3), 0);
+/// assert_eq!(lca.lca(2, 3), 2);
 /// ```
 pub struct LCA {
     tin: Vec<usize>,
-    p: Vec<usize>,
+    p: Vec<Option<usize>>,
     rmq: RMQ<(usize, usize), OpType>,
 }
 
@@ -42,21 +38,28 @@ impl LCA {
     pub fn new(adj: &[Vec<usize>]) -> Self {
         let n = adj.len();
         let mut tin = vec![0; n];
-        let mut p = vec![0; n];
+        let mut p = vec![None; n];
         let mut d = vec![0; n];
         let order = get_dfs_preorder(adj);
         for (i, &u) in order.iter().enumerate() {
             tin[u] = i;
             for &v in &adj[u] {
-                if v != p[u] {
-                    p[v] = u;
-                    d[v] = d[u] + 1;
+                if Some(v) != p[u] {
+                    (p[v], d[v]) = (Some(u), d[u] + 1);
                 }
             }
         }
-        let d_with_order: Vec<(usize, usize)> = order.iter().map(|&u| (d[u], u)).collect();
-        let rmq = RMQ::<(usize, usize), OpType>::new(&d_with_order, std::cmp::min);
-        LCA { tin, p, rmq }
+        LCA {
+            tin,
+            p,
+            rmq: RMQ::new(
+                &order
+                    .iter()
+                    .map(|&u| (d[u], u))
+                    .collect::<Vec<(usize, usize)>>(),
+                std::cmp::min,
+            ),
+        }
     }
 
     /// Gets the lowest common ancestor of u and v
@@ -72,6 +75,6 @@ impl LCA {
         if le > ri {
             std::mem::swap(&mut le, &mut ri);
         }
-        self.p[self.rmq.query(le + 1..ri + 1).1]
+        self.p[self.rmq.query(le + 1..ri + 1).1].unwrap()
     }
 }

src/graphs/scc.rs

@@ -11,19 +11,15 @@ use crate::graphs::dfs_order::get_dfs_postorder;
 /// ```
 /// 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 n = 4;
+/// let mut adj = vec![vec![]; n];
+/// for (u, v) in [(0,1), (1,2), (2,0), (1,3), (3,3)] {
+///    adj[u].push(v);
+/// }
 ///
 /// 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]);
+/// assert_eq!(num_sccs, 2);
+/// assert_eq!(scc_id, [0, 0, 0, 1]);
 /// ```
 ///
 /// # Complexity