Submission #1214379

#	Time	Username	Problem	Language	Result	Execution time	Memory
1214379		VMaksimoski008	Progression (NOI20_progression)	C++20	0 / 100	574 ms	1114112 KiB

Progression

#include <bits/stdc++.h>
#define ar array
//#define int long long

using namespace std;

using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

const int mod = 1e9 + 7;
const ll inf = 5e18;
const int N = 1e5 + 5;

struct node {
    int tl, tr;
    ll pref, suf, ans, l, r;

    node(ll _v=0, int _tl=0, int _tr=0) : tl(_tl), tr(_tr) {
        pref = suf = ans = 1;
        l = r = _v;
    }
};

node merge(node a, node b) {
    if(a.l == -inf) return b;
    if(b.l == -inf) return a;
    node res;
    res.pref = a.pref;
    res.suf = b.suf;
    res.tl = a.tl;
    res.tr = b.tr;
    res.l = a.l;
    res.r = b.r;
    res.ans = max(a.ans, b.ans);
    if(a.r == b.l) res.ans = max(res.ans, a.suf + b.pref);
    if(a.pref == a.tr-a.tl+1 && a.r == b.l) res.pref = a.ans + b.pref;
    if(b.suf == b.tr-b.tl+1 && a.r == b.l) res.suf = a.suf + b.ans;
    return res;
}

struct segment_tree {
    int n;
    vector<node> tree;
    vector<ll> lazy;

    segment_tree(int _n) : n(_n), tree(4*n), lazy(4*n) {
        build(1, 1, n);
    }

    void build(int u, int tl, int tr) {
        if(tl == tr) {
            tree[u].l = tree[u].r = 0;
            tree[u].tl = tl;
            tree[u].tr = tr;
        } else {
            int tm = (tl + tr) / 2;
            build(2*u, tl, tm);
            build(2*u+1, tm+1, tr);
            tree[u] = merge(tree[2*u], tree[2*u+1]);
        }
    }

    void push(int u, int tl, int tr) {
        if(lazy[u] == 0) return ;
        tree[u].l += lazy[u];
        tree[u].r += lazy[u];

        if(tl != tr) {
            lazy[2*u] += lazy[u];
            lazy[2*u+1] += lazy[u];
        }

        lazy[u] = 0;
    }

    void update(int u, int tl, int tr, int l, int r, ll v) {
        push(u, tl, tr);
        if(tl > r || l > tr) return ;

        if(l <= tl && tr <= r) {
            lazy[u] += v;
            push(u, tl, tr);
            return ;
        }

        int tm = (tl + tr) / 2;
        update(2*u, tl, tm, l, r, v);
        update(2*u+1, tm+1, tr, l, r, v);
        tree[u] = merge( tree[2*u], tree[2*u+1] );
    }

    node query(int u, int tl, int tr, int l, int r) {
        if(tl > r || l > tr) return node(-inf);
        push(u, tl, tr);
        if(l <= tl && tr <= r) return tree[u];
        int tm = (tl + tr) / 2;
        return merge( query(2*u, tl, tm, l, r), query(2*u+1, tm+1, tr, l, r) );
    }

    void update(int l, int r, ll v) { update(1, 1, n, l, r, v); }
    node query(int l, int r) { return query(1, 1, n, l, r); }
};

signed main() {
    ios_base::sync_with_stdio(false);
    cout.tie(0); cin.tie(0);

    int n, q; cin >> n >> q;
    vector<ll> a(n+1);
    segment_tree sgt(n-1);
    for(int i=1; i<=n; i++) {
        cin >> a[i];
        if(i > 1) sgt.update(i-1, i-1, a[i] - a[i-1]);
    }
    while(q--) {
        int t, l, r; cin >> t >> l >> r;

        if(t == 3) {
            if(l == r) {
                cout << 1 << '\n';
                continue;
            }
            node res = sgt.query(l, r-1);
            cout << sgt.query(l, r-1).ans + 1 << '\n';
        } else if(t == 1) {
            ll s, c; cin >> s >> c;
            
        } else if(t == 2) {
            ll s, c; cin >> s >> c;
            
        }
    }
}

• Subtask 1: 0 / 9
• Subtask 2: 0 / 15
• Subtask 3: 0 / 35
• Subtask 4: 0 / 11
• Subtask 5: 0 / 13
• Subtask 6: 0 / 17