Submission #1239743

#	Time	Username	Problem	Language	Result	Execution time	Memory
1239743		lunarecho	Simple (info1cup19_simple)	C++20	100 / 100	308 ms	27336 KiB

subway

#include <bits/stdc++.h>
using namespace std;
#define ll long long

struct node {

    ll max_odd,min_odd,max_even,min_even;

};

struct SGT {

    node merge(node a,node b)
    {
        return {max(a.max_odd,b.max_odd),min(a.min_odd,b.min_odd),max(a.max_even,b.max_even),min(a.min_even,b.min_even)};
    }

    vector<node> tree;
    vector<ll> lazy;
    int sz;

    void init(int n)
    {
        sz = 1;
        while(sz < n)
            sz <<= 1;
        tree.resize(2*sz);
        lazy.resize(2*sz,0LL);
    }
    void build(vector<ll>& a, int x,int lx,int rx)
    {
        if(rx - lx == 1)
        {
            if(lx < (int) a.size())
            {
                if(a[lx] & 1)
                {
                    tree[x].max_odd = a[lx];
                    tree[x].min_odd = a[lx];
                    tree[x].min_even = LLONG_MAX;
                    tree[x].max_even = LLONG_MIN;
                }
                else
                {
                    tree[x].max_even = a[lx];
                    tree[x].min_even = a[lx];
                    tree[x].max_odd = LLONG_MIN;
                    tree[x].min_odd = LLONG_MAX;
                }
            }
            return;
        }
        int m = (lx + rx) / 2;
        build(a,2*x+1,lx,m);
        build(a,2*x+2,m,rx);
        tree[x] = merge(tree[2*x+1],tree[2*x+2]);
    }

    void build(vector<ll>& a)
    {
        build(a,0,0,sz);
    }

    void push(int x,int lx,int rx)
    {
        if(lazy[x] != 0)
        {
            if(rx - lx != 1)
            {
                lazy[2*x+1] += lazy[x];
                lazy[2*x+2] += lazy[x];
            }
            if(tree[x].min_even != LLONG_MAX)
                    tree[x].min_even += lazy[x];
                if(tree[x].max_even != LLONG_MIN)
                    tree[x].max_even += lazy[x];
                if(tree[x].max_odd != LLONG_MIN)
                    tree[x].max_odd += lazy[x];
                if(tree[x].min_odd != LLONG_MAX)
                    tree[x].min_odd += lazy[x];
            if(lazy[x] & 1)
            {
                swap(tree[x].min_even,tree[x].min_odd);
                swap(tree[x].max_odd,tree[x].max_even);
            }
            lazy[x] = 0;
        }
    }

    void update(int l,int r,ll v,int x,int lx,int rx)
    {
        push(x,lx,rx);
        if(lx >= r || rx <= l)
            return;
        if(lx >= l and rx <= r)
        {
            lazy[x] += v;
            push(x,lx,rx);
            return;
        }
        int m = (lx + rx) / 2;
        update(l,r,v,2*x+1,lx,m);
        update(l,r,v,2*x+2,m,rx);
        tree[x] = merge(tree[2*x+1],tree[2*x+2]);
    }

    void update(int l,int r, ll v)
    {
        update(l,r,v,0,0,sz);
    }

    node query(int l,int r,int x,int lx,int rx)
    {
        push(x,lx,rx);
        if(lx >= r || rx <= l)
            return {LLONG_MIN,LLONG_MAX,LLONG_MIN,LLONG_MAX};
        if(lx >= l and rx <= r)
            return tree[x];
        int m = (lx + rx) / 2;
        return merge(query(l,r,2*x+1,lx,m), query(l,r,2*x+2,m,rx));   
    }

    node query(int l,int r)
    {
        return query(l,r,0,0,sz);
    }

};

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

    int n;
    cin>>n;
    vector<ll> a(n);
    for(auto &it : a)
        cin>>it;
    SGT st;
    st.init(n);
    st.build(a);
    int q;
    cin>>q;
    while(q--)
    {
        int type;
        cin>>type;
        if(type == 0)
        {
            int l,r;
            ll v;
            cin>>l>>r>>v;
            st.update(--l,r,v);
        }
        else if(type == 1)
        {
            int l,r;
            cin>>l>>r;
            --l;
            node get_ans = st.query(l,r);
            cout<<(get_ans.min_even == LLONG_MAX ? -1 : get_ans.min_even)<<' '<<(get_ans.max_odd == LLONG_MIN ? -1 : get_ans.max_odd)<<'\n';
        }
    }

    return 0;
}

• Subtask 1: 30 / 30
• Subtask 2: 30 / 30
• Subtask 3: 40 / 40