Merge branch 'main' into compress_tree

Author: lrvideckis

Cargo.toml

@@ -219,3 +219,15 @@ path = "examples/monotonic/count_rects.rs"
 [[example]]
 name = "cartesian_tree"
 path = "examples/monotonic/cartesian_tree.rs"
+
+[[example]]
+name = "fenwick_kth"
+path = "examples/data_structures/fenwick_kth.rs"
+
+[[example]]
+name = "disjoint_rmq_non_commutative"
+path = "examples/data_structures/disjoint_rmq_non_commutative.rs"
+
+[[example]]
+name = "lca_rmq_next_on_path"
+path = "examples/graphs/lca_rmq_next_on_path.rs"

examples/data_structures/binary_trie.rs

@@ -12,7 +12,7 @@ fn main() {
     for _ in 0..q {
         input! {
             t: u8,
-            x: usize,
+            x: u32,
         }
 
         match t {

examples/data_structures/disjoint_rmq_non_commutative.rs

@@ -0,0 +1,51 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/queue_operate_all_composite
+
+use proconio::input;
+use programming_team_code_rust::data_structures::disjoint_rmq::DisjointRMQ;
+
+const MOD: u64 = 998_244_353;
+
+fn main() {
+    input! {
+        q: usize,
+    }
+
+    let mut que = Vec::new();
+    let mut front = 0;
+    let mut queries = Vec::new();
+
+    for _ in 0..q {
+        input! {
+            t: u8,
+        }
+        match t {
+            0 => {
+                input! {
+                    a: u64,
+                    b: u64,
+                }
+                que.push((a, b));
+            }
+            1 => {
+                front += 1;
+            }
+            _ => {
+                input! {
+                    x: u64,
+                }
+                queries.push((front..que.len(), x));
+            }
+        }
+    }
+
+    let d_rmq = DisjointRMQ::new(&que, |&a, &b| (a.0 * b.0 % MOD, (b.0 * a.1 + b.1) % MOD));
+
+    for (range, x) in queries {
+        if range.is_empty() {
+            println!("{}", x);
+        } else {
+            let (slope, y_int) = d_rmq.query(range);
+            println!("{}", (slope * x + y_int) % MOD);
+        }
+    }
+}

examples/data_structures/fenwick_kth.rs

@@ -0,0 +1,54 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/predecessor_problem
+
+use proconio::input;
+use programming_team_code_rust::data_structures::fenwick::Fenwick;
+
+fn main() {
+    input! {
+        n: usize,
+        q: usize,
+        s: String,
+    }
+
+    let mut fenwick =
+        Fenwick::<i32>::build_on_array(&s.chars().map(|c| (c == '1') as i32).collect::<Vec<_>>());
+
+    for _ in 0..q {
+        input! {
+            t: u8,
+            k: usize,
+        }
+        match t {
+            0 => {
+                if fenwick.sum(k..k + 1) == 0 {
+                    fenwick.add(k, 1);
+                }
+            }
+            1 => {
+                if fenwick.sum(k..k + 1) == 1 {
+                    fenwick.add(k, -1);
+                }
+            }
+            2 => {
+                println!("{}", fenwick.sum(k..k + 1));
+            }
+            3 => {
+                let cnt = fenwick.sum(0..k);
+                let res = fenwick.kth(cnt + 1);
+                if res == n {
+                    println!("-1");
+                } else {
+                    println!("{}", res);
+                }
+            }
+            _ => {
+                let cnt_le = fenwick.sum(0..k + 1);
+                if cnt_le == 0 {
+                    println!("-1");
+                } else {
+                    println!("{}", fenwick.kth(cnt_le));
+                }
+            }
+        }
+    }
+}

examples/data_structures/rmq.rs

@@ -10,7 +10,7 @@ fn main() {
         a: [usize; n],
     }
 
-    let rmq = RMQ::new(&a, std::cmp::min);
+    let rmq = RMQ::new(&a, |&x, &y| std::cmp::min(x, y));
     for _ in 0..q {
         input! {
             le: usize,

examples/data_structures/seg_tree_aizu.rs

@@ -8,7 +8,7 @@ fn main() {
         n: usize,
         q: usize,
     }
-    let mut st = SegTree::<usize>::new(n, |x, y| x + y, 0);
+    let mut st = SegTree::new(n, |x, y| x + y, 0);
     for _ in 0..q {
         input! {
             t: u8,

examples/data_structures/seg_tree_yosupo.rs

@@ -21,7 +21,7 @@ fn main() {
         })
         .collect::<Vec<(u64, u64)>>();
 
-    let mut seg_tree = SegTree::<(u64, u64)>::build_on_array(
+    let mut seg_tree = SegTree::build_on_array(
         &a,
         |x, y| (x.0 * y.0 % MOD, (y.0 * x.1 + y.1) % MOD),
         (1, 0),

examples/graphs/hld_path_composite_yosupo.rs

@@ -39,12 +39,12 @@ fn main() {
         input_a[hld.tin[i]] = elem;
     }
 
-    let mut st_forwards = SegTree::<(u64, u64)>::build_on_array(
+    let mut st_forwards = SegTree::build_on_array(
         &input_a,
         |x, y| (x.0 * y.0 % MOD, (y.0 * x.1 + y.1) % MOD),
         (1, 0),
     );
-    let mut st_backwards = SegTree::<(u64, u64)>::build_on_array(
+    let mut st_backwards = SegTree::build_on_array(
         &input_a,
         |x, y| (x.0 * y.0 % MOD, (x.0 * y.1 + x.1) % MOD),
         (1, 0),

examples/graphs/lca_rmq_next_on_path.rs

@@ -0,0 +1,65 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/tree_diameter
+
+use proconio::input;
+use programming_team_code_rust::graphs::lca::LCA;
+
+fn main() {
+    input! {
+        n: usize,
+    }
+
+    let mut adj = vec![vec![]; n];
+    let mut adj_w = vec![vec![]; n];
+    for _ in 1..n {
+        input! {
+            u: usize,
+            v: usize,
+            w: i64,
+        }
+        adj[u].push(v);
+        adj[v].push(u);
+        adj_w[u].push((v, w));
+        adj_w[v].push((u, w));
+    }
+
+    let lca = LCA::new(&adj);
+
+    let mut dist_root = vec![0; n];
+    fn dfs(u: usize, p: Option<usize>, adj_w: &[Vec<(usize, i64)>], dist_root: &mut Vec<i64>) {
+        for &(v, w) in &adj_w[u] {
+            if Some(v) == p {
+                continue;
+            }
+            dist_root[v] = w + dist_root[u];
+            dfs(v, Some(u), adj_w, dist_root);
+        }
+    }
+
+    dfs(0, None, &adj_w, &mut dist_root);
+
+    let dist_path =
+        |u: usize, v: usize| -> i64 { dist_root[u] + dist_root[v] - 2 * dist_root[lca.lca(u, v)] };
+
+    let mut u = 0;
+    for i in 1..n {
+        if dist_path(0, u) < dist_path(0, i) {
+            u = i;
+        }
+    }
+
+    let mut v = 0;
+    for i in 1..n {
+        if dist_path(u, v) < dist_path(u, i) {
+            v = i;
+        }
+    }
+
+    println!("{} {}", dist_path(u, v), lca.dist(u, v) + 1);
+
+    print!("{} ", u);
+    while u != v {
+        u = lca.next_on_path(u, v);
+        print!(" {}", u);
+    }
+    println!();
+}

examples/helpers/lis_aizu.rs

@@ -11,9 +11,16 @@ fn main() {
 
     let mut lis = Lis::default();
 
-    for elem in a {
+    assert_eq!(lis.get_lis(), vec![]);
+
+    for &elem in &a {
         lis.push(elem);
     }
 
-    println!("{}", lis.dp.len());
+    let idxs = lis.get_lis();
+    for i in 1..idxs.len() {
+        assert!(a[idxs[i - 1]] < a[idxs[i]]);
+    }
+
+    println!("{}", idxs.len());
 }