結果

問題 No.230 Splarraay ｽﾌﾟﾗﾚｪｰｲ
コンテスト
ユーザー nebukuro09
提出日時 2017-04-05 17:31:33
言語 D
(dmd 2.109.1)
結果
WA  
実行時間 -
コード長 3,061 bytes
コンパイル時間 607 ms
コンパイル使用メモリ 117,952 KB
実行使用メモリ 12,344 KB
最終ジャッジ日時 2024-06-12 18:36:57
合計ジャッジ時間 8,182 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 1 WA * 5 TLE * 1 -- * 10
権限があれば一括ダウンロードができます

ソースコード

diff # 

import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;

void main() {
    auto N = readln.chomp.to!int;
    auto Q = readln.chomp.to!int;

    auto st = new LazySegmentTree!(int, (a,b)=>a+b)(N);
    long score1 = 0;
    long score2 = 0;
    
    foreach (q; 0..Q) {
        auto s = readln.split.map!(to!int);
        auto x = s[0];
        auto l = s[1];
        auto r = s[2];
        
        if (x == 0) {
            auto m = st.getVal(l, r);
            auto a = (r - l + 1 + m) / 2;
            auto b =  r - l + 1 - a;
            if (m > 0) score1 += a;
            if (m < 0) score2 += b;
        }
        else if (x == 1) {
            st.assign(l, r, 1);
        }
        else if (x == 2) {
            st.assign(l, r, -1);
        }

    }

    auto m = st.getVal(0, N-1);
    auto a = (N + m) / 2;
    auto b =  N - a;
    score1 += a;
    score2 += b;
    
    writeln(score1, " ", score2);
}


class LazySegmentTree(T, alias op) {
    T[] table;
    T[] lazy_;
    int size;
 
    this(int n) {
        assert(bsr(n) < 29);
        size = 1 << (bsr(n) + 2);
        table = new T[](size);
        lazy_ = new T[](size);
        fill(table, 0);
        fill(lazy_, 0);
    }
 
    void assign(int left, int right, T num) {
        return assign(left, right, num, 0, 0, size/2-1);
    }
 
    void assign(int left, int right, T num, int i, int seg_left, int seg_right) {
        if (left > seg_right || right < seg_left) {
            return;
        }
 
        if (left <= seg_left && seg_right <= right) {
            lazy_[i] = num;
            return;
        }
        else {
            if (lazy_[i] != 0) {
                lazy_[i*2+1] = lazy_[i];
                lazy_[i*2+2] = lazy_[i];
                lazy_[i] = 0;
            }
            assign(left, right, num, i*2+1, seg_left, (seg_left+seg_right)/2);
            assign(left, right, num, i*2+2, (seg_left+seg_right)/2+1, seg_right);
        }
    }
 
    T getVal(int left, int right) {
        return getVal(left, right, 0, 0, size/2-1);
    }
 
    T getVal(int left, int right, int i, int seg_left, int seg_right) {
        if (left > seg_right || right < seg_left) {
            return 0;
        }
        else if (seg_left == seg_right) {
            if (lazy_[i] != 0) {
                table[i] = lazy_[i];
                lazy_[i] = 0;
            }
            return table[i];
        }

        if (lazy_[i] != 0) {
            lazy_[i*2+1] = lazy_[i];
            lazy_[i*2+2] = lazy_[i];
            lazy_[i] = 0;
        }
        table[i] = op(getVal(left, right, i*2+1, seg_left, (seg_left+seg_right)/2),
                      getVal(left, right, i*2+2, (seg_left+seg_right)/2+1, seg_right));
        return table[i];
    }
}


unittest {
    auto st = new LazySegmentTree!(int, (a,b)=>a+b)(30);
    st.assign(5, 24, 10);
    assert(st.getVal(5, 24) == 200); 
    assert(st.getVal(5, 14) == 100);
    assert(st.getVal(27, 29) == 0);
}
0