結果

問題 No.1000 Point Add and Array Add
ユーザー akakimidoriakakimidori
提出日時 2020-03-01 14:55:58
言語 Rust
(1.77.0)
結果
AC  
実行時間 184 ms / 2,000 ms
コード長 3,453 bytes
コンパイル時間 6,364 ms
コンパイル使用メモリ 154,624 KB
実行使用メモリ 17,664 KB
最終ジャッジ日時 2024-04-21 22:16:21
合計ジャッジ時間 4,287 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
5,248 KB
testcase_01 AC 1 ms
5,376 KB
testcase_02 AC 1 ms
5,376 KB
testcase_03 AC 1 ms
5,376 KB
testcase_04 AC 1 ms
5,376 KB
testcase_05 AC 1 ms
5,376 KB
testcase_06 AC 1 ms
5,376 KB
testcase_07 AC 1 ms
5,376 KB
testcase_08 AC 1 ms
5,376 KB
testcase_09 AC 1 ms
5,376 KB
testcase_10 AC 1 ms
5,376 KB
testcase_11 AC 1 ms
5,376 KB
testcase_12 AC 2 ms
5,376 KB
testcase_13 AC 1 ms
5,376 KB
testcase_14 AC 2 ms
5,376 KB
testcase_15 AC 1 ms
5,376 KB
testcase_16 AC 96 ms
15,308 KB
testcase_17 AC 82 ms
11,392 KB
testcase_18 AC 140 ms
17,664 KB
testcase_19 AC 141 ms
17,664 KB
testcase_20 AC 57 ms
14,424 KB
testcase_21 AC 184 ms
16,604 KB
testcase_22 AC 98 ms
15,920 KB
testcase_23 AC 166 ms
16,308 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

// ---------- begin SegmentTree Range update Point query ----------
mod segment_tree {
    pub struct RUPQ<T, F> {
        n: usize,
        b: usize,
        a: Vec<T>,
        id: T,
        op: F,
    }
    impl<T: Copy, F: Fn(T, T) -> T> RUPQ<T, F> {
        pub fn new(n: usize, id: T, op: F) -> RUPQ<T, F> {
            let mut k = 0;
            while (1 << k) < n {
                k += 1;
            }
            RUPQ {
                n: 1 << k,
                b: k,
                a: vec![id; 2 << k],
                id: id,
                op: op,
            }
        }
        fn down(&mut self, x: usize) {
            let k = x + self.n;
            let a = &mut self.a;
            for i in (1..(self.b + 1)).rev() {
                let y = k >> i;
                a[2 * y] = (self.op)(a[2 * y], a[y]);
                a[2 * y + 1] = (self.op)(a[2 * y + 1], a[y]);
                a[y] = self.id;
            }
        }
        pub fn update(&mut self, mut l: usize, mut r: usize, v: T) {
            self.down(l);
            self.down(r - 1);
            l += self.n;
            r += self.n;
            let a = &mut self.a;
            while l < r {
                if (l & 1) == 1 {
                    a[l] = (self.op)(a[l], v);
                    l += 1;
                }
                if (r & 1) == 1 {
                    r -= 1;
                    a[r] = (self.op)(a[r], v);
                }
                l >>= 1;
                r >>= 1;
            }
        }
        pub fn find(&mut self, mut x: usize) -> T {
            x += self.n;
            let mut y = self.a[x];
            x >>= 1;
            while x > 0 {
                y = (self.op)(y, self.a[x]);
                x >>= 1;
            }
            y
        }
    }
}
// ---------- end SegmentTree Range update Point query ----------

use std::io::Read;

fn run() {
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    let n: usize = it.next().unwrap().parse().unwrap();
    let q: usize = it.next().unwrap().parse().unwrap();
    let a: Vec<i64> = (0..n).map(|_| it.next().unwrap().parse().unwrap()).collect();
    enum Operation {
        ADD(usize, i64),
        RANGE(usize, usize),
    }
    let mut seg = segment_tree::RUPQ::new(n, 0, |a, b| a + b);
    let mut query = Vec::with_capacity(q);
    for _ in 0..q {
        if it.next().unwrap().chars().next().unwrap() == 'A' {
            let x: usize = it.next().unwrap().parse().unwrap();
            let v: i64 = it.next().unwrap().parse().unwrap();
            query.push(Operation::ADD(x - 1, v));
        } else {
            let x: usize = it.next().unwrap().parse().unwrap();
            let y: usize = it.next().unwrap().parse().unwrap();
            seg.update(x - 1, y, 1);
            query.push(Operation::RANGE(x - 1, y));
        }
    }
    let mut ans = vec![0; n];
    for (i, (ans, a)) in ans.iter_mut().zip(a.iter()).enumerate() {
        *ans = seg.find(i) * *a;
    }
    for op in query {
        match op {
            Operation::ADD(x, v) => {
                ans[x] += v * seg.find(x);
            },
            Operation::RANGE(l, r) => {
                seg.update(l, r, -1);
            }
        }
    }
    let mut out = String::new();
    for a in ans {
        out.push_str(&format!("{} ", a));
    }
    out.pop();
    println!("{}", out);
}

fn main() {
    run();
}
0