結果

問題 No.879 Range Mod 2 Query
ユーザー tatsumacktatsumack
提出日時 2019-11-27 01:03:51
言語 C++11
(gcc 11.4.0)
結果
WA  
実行時間 -
コード長 5,285 bytes
コンパイル時間 3,646 ms
コンパイル使用メモリ 105,156 KB
実行使用メモリ 17,896 KB
最終ジャッジ日時 2024-04-24 16:25:32
合計ジャッジ時間 6,871 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 WA -
testcase_02 WA -
testcase_03 WA -
testcase_04 WA -
testcase_05 WA -
testcase_06 WA -
testcase_07 WA -
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 WA -
testcase_19 AC 273 ms
17,896 KB
testcase_20 AC 261 ms
17,764 KB
testcase_21 AC 273 ms
17,764 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author tatsumack
 */

#include <iostream>
#include <fstream>

#include <iostream>
#include <limits.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>

#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <queue>
#include <unordered_map>
#include <unordered_set>

#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)

using namespace std;

typedef pair<int, int> P;

struct data {
    int odd, even, sum;
};

struct query {
    int sum, swap, upd;

    bool operator==(query rhs) {
        return sum == rhs.sum && rhs.swap == swap && upd == rhs.upd;
    }
};

template<typename T, typename S>
struct LazySegmentTree {
private:
    int n;
    vector<T> node;
    vector<S> lazy;
    T E0;
    S E1;

    inline void updatef(S& lazy, S& value) {
        if (value.sum == -1) {
            lazy.sum = -1;
            lazy.swap ^= value.swap;
            lazy.upd |= value.upd;
        } else {
            if (lazy.sum == -1 || value.upd)lazy.sum = 0;
            lazy.sum += value.sum;
            lazy.swap ^= value.swap;
            lazy.upd |= value.upd;
        }
    }

    inline void calculatef(T& node, S& lazy, int len) {
        if (lazy.sum == -1) {
            if (lazy.swap)swap(node.odd, node.even);
            node.sum = node.odd;
        } else {
            if (lazy.swap)swap(node.odd, node.even);
            if (lazy.upd) {
                if (lazy.sum % 2 == 0)node.sum = node.odd;
                else node.sum = node.even;
            } else {
                node.sum += lazy.sum * len;
            }
        }

    }

    inline T queryf(T& x, T& y) {
        return {x.odd + y.odd, x.even + y.even, x.sum + y.sum};
    }

public:
    LazySegmentTree(int sz, T nodeE, S lazyE) : E0(nodeE), E1(lazyE) {
        n = 1;
        while (n < sz)n <<= 1;
        node.resize(2 * n - 1, E0);
        lazy.resize(2 * n - 1, E1);
    }

    LazySegmentTree(vector<T>& v, T E0, S E1) : E0(E0), E1(E1) {
        n = 1;
        int sz = v.size();
        while (n < sz)n <<= 1;
        node.resize(2 * n - 1, E0);
        lazy.resize(2 * n - 1, E1);
        REP(i, sz)node[i + n - 1] = v[i];
        for (int i = n - 2; i >= 0; --i) {
            node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
        }
    }

    void eval(int k, int l, int r) {
        if (lazy[k] == E1)return;
        calculatef(node[k], lazy[k], r - l);
        if (r - l > 1) {
            updatef(lazy[2 * k + 1], lazy[k]);
            updatef(lazy[2 * k + 2], lazy[k]);
        }
        lazy[k] = E1;
    }

    void update(int a, int b, S x, int k = 0, int l = 0, int r = -1) {
        if (r < 0)r = n;
        eval(k, l, r);
        if (r <= a || b <= l)return;
        if (a <= l && r <= b) {
            updatef(lazy[k], x);
            eval(k, l, r);
        } else {
            update(a, b, x, 2 * k + 1, l, (l + r) / 2);
            update(a, b, x, 2 * k + 2, (l + r) / 2, r);
            node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
        }
    }

    T query(int a, int b, int k = 0, int l = 0, int r = -1) {
        if (r < 0)r = n;
        eval(k, l, r);
        if (r <= a || b <= l)return E0;
        if (a <= l && r <= b)return node[k];
        T xl = query(a, b, 2 * k + 1, l, (l + r) / 2);
        T xr = query(a, b, 2 * k + 2, (l + r) / 2, r);
        return queryf(xl, xr);
    }
};


class RangeMod2Query {
public:
    static constexpr int kStressIterations = 0;

    static void generateTest(std::ostream& test) {
    }

    void solve(std::istream& cin, std::ostream& cout) {
        int N, Q;
        cin >> N >> Q;
        vector<data> A;
        REP(i, N) {
            int x;
            cin >> x;
            if (x & 1) {
                A.push_back({1, 0, x});
            } else {
                A.push_back({0, 1, x});
            }
        }

        LazySegmentTree<data, query> seg(A, {0, 0, 0}, {0, 0, 0});
        while (Q--) {
            int t;
            cin >> t;
            int l, r;
            cin >> l >> r;
            if (t == 1) {
                seg.update(l - 1, r, {-1, 0, 1});
            } else if (t == 2) {
                int x;
                cin >> x;
                seg.update(l - 1, r, {x, x & 1, 0});
            } else {
                cout << seg.query(l - 1, r).sum << endl;
            }
        }
    }
};


signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    std::istream& in(std::cin);
    std::ostream& out(std::cout);

    RangeMod2Query solver;
    solver.solve(in, out);
    return 0;
}
0