complete 2042.rs 2357.rs 6549.rs 10090.rs

storage/zeta/rs/completed/10090.rs

@@ -0,0 +1,62 @@
+use std::io::{read_to_string, stdin};
+
+fn invcnt(arr: &mut Vec<usize>, lo: usize, hi: usize) -> usize {
+    let delta = hi - lo;
+    if delta == 0 {
+        return 0;
+    } else if delta == 1 {
+        return 0;
+    } else if delta == 2 {
+        if arr[lo] > arr[lo + 1] {
+            let temp = arr[lo + 1];
+            arr[lo + 1] = arr[lo];
+            arr[lo] = temp;
+            return 1;
+        } else {
+            return 0;
+        }
+    } else {
+        let mut res = 0;
+        let mut left = lo;
+        let mut right = (lo + hi) / 2;
+        let left_end = right;
+        let right_end = hi;
+        let mut v = vec![];
+        res += invcnt(arr, left, left_end);
+        res += invcnt(arr, right, right_end);
+        while left < left_end && right < right_end {
+            if arr[left] > arr[right] {
+                v.push(arr[right]);
+                res += left_end - left;
+                right += 1;
+            } else {
+                v.push(arr[left]);
+                left += 1;
+            }
+        }
+        while left < left_end {
+            v.push(arr[left]);
+            left += 1;
+        }
+        while right < right_end {
+            v.push(arr[right]);
+            right += 1;
+        }
+        for (i, &e) in v.iter().enumerate() {
+            arr[lo + i] = e;
+        }
+        return res;
+    }
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+    let n = iter.next().unwrap();
+    let mut arr = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+
+    let res = invcnt(&mut arr, 0, n);
+    println!("{}", res);
+}

storage/zeta/rs/completed/2042.rs

@@ -0,0 +1,67 @@
+use std::io::{read_to_string, stdin};
+
+fn init_tree(tree: &mut Vec<i64>, arr: &Vec<i64>, i: usize, l: usize, r: usize) -> i64 {
+    if l == r {
+        tree[i] = arr[l];
+        return arr[l];
+    }
+    let m = (l + r) / 2;
+    tree[i] = init_tree(tree, arr, i * 2 + 1, l, m) + init_tree(tree, arr, 2 * i + 2, m + 1, r);
+    return tree[i];
+}
+
+fn query(tree: &mut Vec<i64>, i: usize, l: usize, r: usize, ql: usize, qr: usize) -> i64 {
+    if r < ql || l > qr {
+        0
+    } else if ql <= l && r <= qr {
+        tree[i]
+    } else {
+        let m = (l + r) / 2;
+        query(tree, 2 * i + 1, l, m, ql, qr) + query(tree, 2 * i + 2, m + 1, r, ql, qr)
+    }
+}
+
+fn update(tree: &mut Vec<i64>, i: usize, l: usize, r: usize, ui: usize, uv: i64) {
+    if l == r {
+        tree[i] = uv;
+        return;
+    }
+    let m: usize = (l + r) / 2;
+    if ui <= m {
+        update(tree, 2 * i + 1, l, m, ui, uv);
+    } else {
+        update(tree, 2 * i + 2, m + 1, r, ui, uv);
+    }
+    tree[i] = tree[2 * i + 1] + tree[2 * i + 2];
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<i64>().unwrap());
+    let (n, m, k) = (
+        iter.next().unwrap() as usize,
+        iter.next().unwrap() as usize,
+        iter.next().unwrap() as usize,
+    );
+    let arr = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+    let mut tree = vec![0; 4 * n];
+
+    init_tree(&mut tree, &arr, 0, 0, n - 1);
+
+    for _ in 0..m + k {
+        let inst = iter.next().unwrap();
+        if inst == 1 {
+            let i = iter.next().unwrap() as usize - 1;
+            let c = iter.next().unwrap();
+            update(&mut tree, 0, 0, n - 1, i, c);
+        } else if inst == 2 {
+            let (i, j) = (
+                iter.next().unwrap() as usize - 1,
+                iter.next().unwrap() as usize - 1,
+            );
+            println!("{}", query(&mut tree, 0, 0, n - 1, i, j));
+        }
+    }
+}

storage/zeta/rs/completed/2357.rs

@@ -0,0 +1,68 @@
+use std::{
+    io::Write,
+    io::{BufWriter, read_to_string, stdin, stdout},
+};
+
+fn init_tree(
+    tree: &mut Vec<(u64, u64)>,
+    arr: &Vec<u64>,
+    i: usize,
+    l: usize,
+    r: usize,
+) -> (u64, u64) {
+    if l == r {
+        tree[i] = (arr[l], arr[l]);
+        return (arr[l], arr[l]);
+    }
+    let m = (l + r) / 2;
+    let (m1, x1) = init_tree(tree, arr, i * 2 + 1, l, m);
+    let (m2, x2) = init_tree(tree, arr, 2 * i + 2, m + 1, r);
+
+    tree[i] = (m1.min(m2), x1.max(x2));
+    return tree[i];
+}
+
+fn query(
+    tree: &mut Vec<(u64, u64)>,
+    i: usize,
+    l: usize,
+    r: usize,
+    ql: usize,
+    qr: usize,
+) -> (u64, u64) {
+    if r < ql || l > qr {
+        (u64::MAX, u64::MIN)
+    } else if ql <= l && r <= qr {
+        tree[i]
+    } else {
+        let m = (l + r) / 2;
+        let (m1, x1) = query(tree, 2 * i + 1, l, m, ql, qr);
+        let (m2, x2) = query(tree, 2 * i + 2, m + 1, r, ql, qr);
+        (m1.min(m2), x1.max(x2))
+    }
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+    let (n, m) = (iter.next().unwrap() as usize, iter.next().unwrap() as usize);
+    let arr = (0..n)
+        .map(|_| iter.next().unwrap() as u64)
+        .collect::<Vec<_>>();
+    let mut tree = vec![(0, 0); 4 * n];
+
+    init_tree(&mut tree, &arr, 0, 0, n - 1);
+
+    let mut out = BufWriter::new(stdout());
+
+    for _ in 0..m {
+        let (i, j) = (
+            iter.next().unwrap() as usize - 1,
+            iter.next().unwrap() as usize - 1,
+        );
+        let (rm, rx) = query(&mut tree, 0, 0, n - 1, i, j);
+        write!(out, "{} {}\n", rm, rx).unwrap();
+    }
+}

storage/zeta/rs/completed/6549.rs

@@ -0,0 +1,45 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+    loop {
+        let n = iter.next().unwrap();
+        if n == 0 {
+            break;
+        }
+
+        let arr = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+
+        let mut stack = vec![(0, 0)];
+        let mut res = 0;
+        for i in 1..=n {
+            let e = arr[i - 1];
+            let (mut top_i, mut top_e) = *stack.last().unwrap();
+
+            while top_e >= e {
+                let (p_i, p_e) = stack.pop().unwrap();
+                if stack.is_empty() {
+                    break;
+                }
+                (top_i, top_e) = *stack.last().unwrap();
+                res = res.max((i - top_i - 1) * p_e);
+            }
+            if stack.is_empty() {
+                stack.push((i, e));
+                continue;
+            }
+            stack.push((i, e));
+            res = res.max((i - top_i) * e);
+        }
+        while stack.len() > 1 {
+            let (ti, te) = stack.pop().unwrap();
+            let (top_i, top_e) = stack.last().unwrap();
+            res = res.max((n - top_i) * te);
+        }
+
+        println!("{}", res);
+    }
+}