結果

問題 No.885 アマリクエリ
ユーザー akakimidoriakakimidori
提出日時 2020-10-26 20:22:25
言語 Rust
(1.77.0)
結果
AC  
実行時間 70 ms / 2,000 ms
コード長 6,061 bytes
コンパイル時間 1,107 ms
コンパイル使用メモリ 152,060 KB
実行使用メモリ 10,396 KB
最終ジャッジ日時 2023-09-29 02:50:26
合計ジャッジ時間 4,933 ms
ジャッジサーバーID
（参考情報） 		judge13 / judge14
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 43 ms
10,392 KB
testcase_01 AC 48 ms
10,392 KB
testcase_02 AC 70 ms
10,388 KB
testcase_03 AC 46 ms
10,372 KB
testcase_04 AC 46 ms
10,364 KB
testcase_05 AC 30 ms
10,372 KB
testcase_06 AC 28 ms
10,396 KB
testcase_07 AC 12 ms
10,324 KB
testcase_08 AC 15 ms
4,380 KB
testcase_09 AC 55 ms
10,368 KB
testcase_10 AC 1 ms
4,376 KB
testcase_11 AC 1 ms
4,380 KB
testcase_12 AC 1 ms
4,376 KB
testcase_13 AC 2 ms
4,380 KB
testcase_14 AC 2 ms
4,376 KB
testcase_15 AC 2 ms
4,380 KB
testcase_16 AC 1 ms
4,380 KB
testcase_17 AC 1 ms
4,380 KB
testcase_18 AC 1 ms
4,376 KB
testcase_19 AC 1 ms
4,504 KB
testcase_20 AC 1 ms
4,376 KB
testcase_21 AC 1 ms
4,376 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

// begin おためしbeats
pub trait Beats {
    type Value: Clone;
    fn merge(l: &Self::Value, r: &Self::Value) -> Self::Value;
    fn propagate(p: &mut Self::Value, c: &mut [Self::Value]);
    fn e() -> Self::Value;
}

pub trait Effect {
    type Value;
    type Query;
    fn break_cond(x: &Self::Value, q: &Self::Query) -> bool;
    fn tag_cond(x: &Self::Value, q: &Self::Query) -> bool;
    fn update(x: &mut Self::Value, q: &Self::Query);
}

struct SegmentTreeBeats<R: Beats> {
    size: usize,
    val: Box<[R::Value]>,
    dfs: Vec<(usize, usize, usize)>,
}

impl<R: Beats> SegmentTreeBeats<R> {
    fn new(ini: &[R::Value]) -> Self {
        let size = ini.len().next_power_of_two();
        let val = vec![R::e(); 2 * size];
        let mut val = val.into_boxed_slice();
        val[size..(size + ini.len())].clone_from_slice(ini);
        for i in (1..size).rev() {
            val[i] = R::merge(&val[2 * i], &val[2 * i + 1]);
        }
        SegmentTreeBeats {
            size,
            val,
            dfs: vec![],
        }
    }
    fn update<E: Effect<Value = R::Value>>(&mut self, x: usize, y: usize, f: E::Query) {
        assert!(x <= y && y <= self.size);
        if x >= y {
            return;
        }
        let val = &mut self.val;
        self.dfs.push((1, 0, self.size));
        while let Some((k, l, r)) = self.dfs.pop() {
            if k > 2 * self.size {
                let k = !k;
                val[k] = R::merge(&val[2 * k], &val[2 * k + 1]);
                continue;
            }
            if E::break_cond(&val[k], &f) {
                continue;
            }
            if x <= l && r <= y && E::tag_cond(&val[k], &f) {
                E::update(&mut val[k], &f);
                continue;
            }
            let (a, b) = val.split_at_mut(2 * k);
            R::propagate(&mut a[k], &mut b[..2]);
            self.dfs.push((!k, l, r));
            let m = (l + r) / 2;
            if m < y {
                self.dfs.push((2 * k + 1, m, r));
            }
            if x < m {
                self.dfs.push((2 * k, l, m));
            }
        }
    }
    fn find(&mut self, x: usize, y: usize) -> R::Value {
        assert!(x <= y && y <= self.size);
        let mut res = R::e();
        if x >= y {
            return res;
        }
        let val = &mut self.val;
        self.dfs.push((1, 0, self.size));
        while let Some((k, l, r)) = self.dfs.pop() {
            if x <= l && r <= y {
                res = R::merge(&res, &val[k]);
                continue;
            }
            let (a, b) = val.split_at_mut(2 * k);
            R::propagate(&mut a[k], &mut b[..2]);
            let m = (l + r) / 2;
            if m < y {
                self.dfs.push((2 * k + 1, m, r));
            }
            if x < m {
                self.dfs.push((2 * k, l, m));
            }
        }
        res
    }
}
// end おためしbeats
// ---------- begin Scanner(require delimiter) ----------
mod scanner {
    pub struct Scanner<R> {
        reader: R,
        buf: Vec<u8>,
    }
    #[allow(dead_code)]
    impl<R: std::io::BufRead> Scanner<R> {
        pub fn new(reader: R) -> Self {
            Scanner {
                reader: reader,
                buf: Vec::with_capacity(1024),
            }
        }
        fn read(&mut self, del: u8) {
            self.buf.clear();
            self.reader.read_until(del, &mut self.buf).ok();
            assert!(self.buf.pop().unwrap() == del);
        }
        pub fn next<T: std::str::FromStr>(&mut self, del: u8) -> T {
            self.read(del);
            std::str::from_utf8(&self.buf)
                .unwrap()
                .trim()
                .parse::<T>()
                .ok()
                .unwrap()
        }
        pub fn next_bytes(&mut self, del: u8) -> Vec<u8> {
            self.read(del);
            std::str::from_utf8(&self.buf)
                .unwrap()
                .trim()
                .bytes()
                .collect()
        }
    }
}
// ---------- end scanner(require delimiter) ----------

use std::io::Write;

fn main() {
    let stdin = std::io::stdin();
    let mut sc = scanner::Scanner::new(stdin.lock());
    run(&mut sc);
}

#[derive(Clone)]
struct Value {
    max: u64,
    sum: u64,
    len: u64,
}

struct Modulo;
impl Effect for Modulo {
    type Value = Value;
    type Query = u64;
    fn break_cond(x: &Self::Value, q: &Self::Query) -> bool {
        *q > x.max
    }
    fn tag_cond(x: &Self::Value, _: &Self::Query) -> bool {
        x.max * x.len == x.sum
    }
    fn update(x: &mut Self::Value, q: &Self::Query) {
        let v = x.max % *q;
        x.max = v;
        x.sum = v * x.len;
    }
}

struct Yuki885;
impl Beats for Yuki885 {
    type Value = Value;
    fn merge(l: &Self::Value, r: &Self::Value) -> Self::Value {
        Value {
            max: std::cmp::max(l.max, r.max),
            sum: l.sum + r.sum,
            len: l.len + r.len,
        }
    }
    fn propagate(p: &mut Self::Value, c: &mut [Self::Value]) {
        let v = p.max;
        if v * p.len == p.sum {
            for c in c.iter_mut() {
                c.max = v;
                c.sum = v * c.len;
            }
        }
    }
    fn e() -> Self::Value {
        Value {
            max: 0,
            sum: 0,
            len: 0,
        }
    }
}

fn run<R: std::io::BufRead>(sc: &mut scanner::Scanner<R>) {
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    let n: usize = sc.next(b'\n');
    let mut ini = Vec::with_capacity(n);
    for i in 0..n {
        let d = if i == n - 1 {b'\n'} else {b' '};
        let v: u64 = sc.next(d);
        ini.push(Value {
            max: v,
            sum: v,
            len: 1,
        });
    }
    let mut seg = SegmentTreeBeats::<Yuki885>::new(&ini);
    let q: usize = sc.next(b'\n');
    for i in 0..q {
        let d = if i == q - 1 {b'\n'} else {b' '};
        let v: u64 = sc.next(d);
        seg.update::<Modulo>(0, n, v);
        writeln!(out, "{}", seg.find(0, n).sum).ok();
    }
}
0