#524444 (C++17) No.945 YKC饅頭

提出ソース

結果

問題	No.945 YKC饅頭
ユーザー	Mister
提出日時	2020-08-04 17:01:30
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	630 ms / 2,000 ms
コード長	4,176 bytes
コンパイル時間	1,564 ms
コンパイル使用メモリ	108,152 KB
実行使用メモリ	11,496 KB
最終ジャッジ日時	2024-09-14 19:08:17
合計ジャッジ時間	16,302 ms
ジャッジサーバーID （参考情報）	judge5 / judge1

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 6,816 KB
testcase_01	AC	2 ms 6,940 KB
testcase_02	AC	2 ms 6,944 KB
testcase_03	AC	3 ms 6,940 KB
testcase_04	AC	2 ms 6,940 KB
testcase_05	AC	2 ms 6,940 KB
testcase_06	AC	3 ms 6,940 KB
testcase_07	AC	3 ms 6,940 KB
testcase_08	AC	2 ms 6,944 KB
testcase_09	AC	3 ms 6,940 KB
testcase_10	AC	2 ms 6,940 KB
testcase_11	AC	2 ms 6,940 KB
testcase_12	AC	2 ms 6,944 KB
testcase_13	AC	3 ms 6,940 KB
testcase_14	AC	3 ms 6,940 KB
testcase_15	AC	2 ms 6,940 KB
testcase_16	AC	3 ms 6,940 KB
testcase_17	AC	2 ms 6,944 KB
testcase_18	AC	3 ms 6,940 KB
testcase_19	AC	2 ms 6,940 KB
testcase_20	AC	2 ms 6,940 KB
testcase_21	AC	2 ms 6,944 KB
testcase_22	AC	3 ms 6,940 KB
testcase_23	AC	3 ms 6,940 KB
testcase_24	AC	3 ms 6,944 KB
testcase_25	AC	3 ms 6,944 KB
testcase_26	AC	3 ms 6,940 KB
testcase_27	AC	2 ms 6,940 KB
testcase_28	AC	2 ms 6,944 KB
testcase_29	AC	2 ms 6,940 KB
testcase_30	AC	2 ms 6,944 KB
testcase_31	AC	31 ms 6,944 KB
testcase_32	AC	45 ms 7,296 KB
testcase_33	AC	148 ms 11,424 KB
testcase_34	AC	290 ms 7,296 KB
testcase_35	AC	517 ms 11,460 KB
testcase_36	AC	276 ms 6,944 KB
testcase_37	AC	269 ms 6,940 KB
testcase_38	AC	270 ms 6,940 KB
testcase_39	AC	87 ms 7,168 KB
testcase_40	AC	96 ms 11,452 KB
testcase_41	AC	48 ms 7,296 KB
testcase_42	AC	433 ms 7,296 KB
testcase_43	AC	224 ms 6,944 KB
testcase_44	AC	390 ms 11,436 KB
testcase_45	AC	460 ms 7,296 KB
testcase_46	AC	28 ms 7,296 KB
testcase_47	AC	293 ms 7,296 KB
testcase_48	AC	52 ms 6,940 KB
testcase_49	AC	137 ms 7,168 KB
testcase_50	AC	491 ms 7,296 KB
testcase_51	AC	630 ms 11,444 KB
testcase_52	AC	620 ms 11,420 KB
testcase_53	AC	626 ms 11,428 KB
testcase_54	AC	619 ms 11,476 KB
testcase_55	AC	623 ms 11,388 KB
testcase_56	AC	67 ms 11,440 KB
testcase_57	AC	65 ms 11,420 KB
testcase_58	AC	222 ms 11,312 KB
testcase_59	AC	264 ms 11,372 KB
testcase_60	AC	135 ms 11,496 KB
testcase_61	AC	241 ms 11,388 KB
testcase_62	AC	229 ms 11,404 KB
testcase_63	AC	67 ms 11,316 KB
testcase_64	AC	142 ms 11,456 KB
testcase_65	AC	127 ms 11,400 KB
testcase_66	AC	120 ms 11,400 KB
testcase_67	AC	188 ms 11,428 KB
testcase_68	AC	136 ms 11,400 KB
testcase_69	AC	87 ms 11,384 KB
testcase_70	AC	92 ms 11,424 KB
testcase_71	AC	93 ms 11,416 KB
testcase_72	AC	160 ms 11,396 KB
testcase_73	AC	245 ms 11,420 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>

template <class T, class E>
struct LazySegmentTree {
    using DMerger = std::function<T(T, T)>;
    using OMerger = std::function<E(E, E)>;
    using Applier = std::function<T(T, E, int)>;

    int length;

    T d_unit;
    E o_unit;

    std::vector<T> dat;
    std::vector<E> ope;

    DMerger dmerge;
    OMerger omerge;
    Applier app;

    explicit LazySegmentTree(int n,
                             T d_unit, E o_unit,
                             DMerger dmerge,
                             OMerger omerge,
                             Applier app)
        : length(1),
          d_unit(d_unit),
          o_unit(o_unit),
          dmerge(dmerge),
          omerge(omerge),
          app(app) {
        while (length < n) length <<= 1;

        dat.assign(length * 2, d_unit);
        ope.assign(length * 2, o_unit);
    }

    template <class Container>
    explicit LazySegmentTree(const Container& elems,
                             T d_unit, E o_unit,
                             DMerger dmerge,
                             OMerger omerge,
                             Applier app)
        : length(1),
          d_unit(d_unit),
          o_unit(o_unit),
          dmerge(dmerge),
          omerge(omerge),
          app(app) {
        int n = elems.size();
        while (length < n) length <<= 1;

        dat.assign(length * 2, d_unit);
        ope.assign(length * 2, o_unit);

        std::copy(elems.begin(), elems.end(), dat.begin() + length);

        for (int nidx = length - 1; nidx >= 1; --nidx) {
            T vl = dat[nidx * 2 + 0];
            T vr = dat[nidx * 2 + 1];
            dat[nidx] = dmerge(vl, vr);
        }
    }

    void propagate(int nidx, int len) {
        if (ope[nidx] == o_unit) return;

        // propagate
        if (len > 1) {
            ope[nidx * 2 + 0] = omerge(ope[nidx * 2 + 0], ope[nidx]);
            ope[nidx * 2 + 1] = omerge(ope[nidx * 2 + 1], ope[nidx]);
        }

        // update data
        dat[nidx] = app(dat[nidx], ope[nidx], len);
        ope[nidx] = o_unit;
    }

    void update(int ql, int qr, E e, int nidx, int nl, int nr) {
        propagate(nidx, nr - nl);

        if (nr <= ql || qr <= nl) return;
        if (ql <= nl && nr <= qr) {
            ope[nidx] = omerge(ope[nidx], e);
            propagate(nidx, nr - nl);
            return;
        }

        int nm = (nl + nr) / 2;
        update(ql, qr, e, nidx * 2 + 0, nl, nm);
        update(ql, qr, e, nidx * 2 + 1, nm, nr);

        // update data
        dat[nidx] = dmerge(dat[nidx * 2 + 0], dat[nidx * 2 + 1]);
    }

    void update(int ql, int qr, E e) { return update(ql, qr, e, 1, 0, length); }

    T fold(int ql, int qr, int nidx, int nl, int nr) {
        propagate(nidx, nr - nl);

        if (nr <= ql || qr <= nl) return d_unit;
        if (ql <= nl && nr <= qr) return dat[nidx];

        int nm = (nl + nr) / 2;
        T vl = fold(ql, qr, nidx * 2 + 0, nl, nm);
        T vr = fold(ql, qr, nidx * 2 + 1, nm, nr);
        return dmerge(vl, vr);
    }

    T fold(int ql, int qr) { return fold(ql, qr, 1, 0, length); }

    T get(int idx) { return fold(idx, idx + 1); }
    T fold_all() { return fold(0, length); }
};

void solve() {
    int n, q;
    std::cin >> n >> q;

    LazySegmentTree<std::pair<int, char>, std::pair<int, char>>
        seg(
            n, std::make_pair(q, '$'), std::make_pair(q, '$'),
            [](auto a, auto b) { return std::min(a, b); },
            [](auto e, auto f) { return std::min(e, f); },
            [](auto a, auto e, int) { return std::min(a, e); });

    for (int i = 0; i < q; ++i) {
        int l, r;
        char t;
        std::cin >> l >> r >> t;
        seg.update(--l, r, std::make_pair(i, t));
    }

    std::vector<int> ans(3, 0);
    for (int i = 0; i < n; ++i) {
        auto t = seg.get(i).second;
        for (int j = 0; j < 3; ++j) {
            if (t == "YKC"[j]) ++ans[j];
        }
    }

    for (auto a : ans) std::cout << a << " ";
    std::cout << "\n";
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    solve();

    return 0;
}

yukicoder

結果

テストケース

ソースコード