bouzuya.hatenablog.com

ぼうずやのにっき

体調が悪い / Slay the Spire サイレント A6H / PAST #2 N

体調が悪い。鼻が詰まっているけど鼻水が出る。体がだるい。薬を飲んで寝る。

Slay the Spire サイレント A6H

  • ボスレリックはスレイバーの首輪・漂う凧
  • 攻撃は腹裂き・幻影の暗殺者・威風堂々
  • 防御は悪夢・残像+・フットワーク+・アイスクリーム・2x策士+・3xバックフリップ
  • 一層でうまくアタックを拾えずエリートを避けることになった
  • ショップで全額使って買った狂信者ポーションでスライムボスを抜けた
  • 一層通過時点でスターター・凍った卵・スレイバーの首輪しかレリックがなかった
  • 二層では策士+が2枚出たけどドローカードがほとんどこなかった
  • 二層の最後で手に入れた悪夢でパワーを増やしてチャンプを抜けた
  • 三層ではアイスクリームを手に入れた
  • 三層の最後で手に入れたアクロバットでなんとかなりそうな感じになった
  • 三層は脱力が切れるとブロックが追いつかない
use lazysegtree::*;
use segtree::*;
use std::{
    cmp::Reverse,
    collections::{BTreeMap, BTreeSet, BinaryHeap},
};

use proconio::input;

fn main() {
    input! {
        n: usize,
        q: usize,
        xydc: [(i64, i64, i64, i64); n],
        ab: [(i64, i64); q],
    }

    #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
    enum T {
        A(i64, i64, i64, i64),
        P(i64, i64, usize),
        R(i64, i64, i64, i64),
    }

    let mut events = BinaryHeap::new();
    let mut xs = BTreeSet::new();

    for (x, y, d, c) in xydc.iter().copied() {
        events.push((Reverse(y), Reverse(T::A(x, y, d, c))));
        events.push((Reverse(y + d), Reverse(T::R(x, y, d, c))));
        xs.insert(x);
        xs.insert(x + d);
    }

    for (i, (a, b)) in ab.iter().copied().enumerate() {
        events.push((Reverse(b), Reverse(T::P(a, b, i))));
        xs.insert(a);
    }

    let map = xs
        .iter()
        .copied()
        .enumerate()
        .fold(BTreeMap::new(), |mut m, (i, k)| {
            m.insert(k, i);
            m
        });

    let m = map.len();

    #[derive(Clone, Copy)]
    struct M(i64);
    impl Monoid for M {
        type S = M;

        fn identity() -> Self::S {
            M(0)
        }

        fn binary_operation(a: &Self::S, b: &Self::S) -> Self::S {
            M(a.0 + b.0)
        }
    }

    #[derive(Clone, Copy)]
    struct F(i64);
    impl MapMonoid for F {
        type M = M;
        type F = F;

        fn identity_map() -> Self::F {
            F(0)
        }

        fn mapping(f: &Self::F, x: &<Self::M as Monoid>::S) -> <Self::M as Monoid>::S {
            M(f.0 + x.0)
        }

        fn composition(f: &Self::F, g: &Self::F) -> Self::F {
            F(f.0 + g.0)
        }
    }

    let mut ans = vec![0; q];
    let mut lst = LazySegtree::<F>::new(m);
    while let Some((Reverse(_), Reverse(t))) = events.pop() {
        match t {
            T::A(x, _, d, c) => {
                let l = map[&x];
                let r = map[&(x + d)];
                lst.apply_range(l..=r, F(c));
            }
            T::R(x, _, d, c) => {
                let l = map[&x];
                let r = map[&(x + d)];
                lst.apply_range(l..=r, F(-c));
            }
            T::P(a, _, i) => {
                let l = map[&a];
                ans[i] = lst.get(l).0;
            }
        }
    }

    for a in ans {
        println!("{}", a);
    }
}

// lazysegtree

今日のコミット。