oj.uz

답안 #985852

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
985852 2024-05-19T06:45:49 Z GrindMachine Fish 2 (JOI22_fish2) C++17
31 / 100
 2379 ms 30636 KB 
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL)
#define pb push_back
#define endl '\n'
#define sz(a) (int)a.size()
#define setbits(x) __builtin_popcountll(x)
#define ff first
#define ss second
#define conts continue
#define ceil2(x,y) ((x+y-1)/(y))
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl

#define rep(i,n) for(int i = 0; i < n; ++i)
#define rep1(i,n) for(int i = 1; i <= n; ++i)
#define rev(i,s,e) for(int i = s; i >= e; --i)
#define trav(i,a) for(auto &i : a)

template<typename T>
void amin(T &a, T b) {
    a = min(a,b);
}

template<typename T>
void amax(T &a, T b) {
    a = max(a,b);
}

#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#endif

/*

refs:
https://codeforces.com/blog/entry/101003?#comment-898608

*/

const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const int inf1 = int(1e9) + 5;
const ll inf2 = ll(1e18) + 5;

template<typename T>
struct lazysegtree {
    /*=======================================================*/

    struct data {
        ll mn,cnt;
    };

    struct lazy {
        ll a;
    };

    data d_neutral = {inf2,0};
    lazy l_neutral = {0};

    void merge(data &curr, data &left, data &right) {
        curr.mn = min(left.mn,right.mn);
        curr.cnt = 0;
        if(left.mn == curr.mn) curr.cnt += left.cnt;
        if(right.mn == curr.mn) curr.cnt += right.cnt;
    }

    void create(int x, int lx, int rx, T v) {
        tr[x] = {v,1};
    }

    void modify(int x, int lx, int rx, T v) {
        lz[x].a = v;
    }

    void propagate(int x, int lx, int rx) {
        ll v = lz[x].a;
        if(!v) return;

        tr[x].mn += v;

        if(rx-lx > 1){
            lz[2*x+1].a += v;
            lz[2*x+2].a += v;
        }

        lz[x] = l_neutral;
    }

    /*=======================================================*/

    int siz = 1;
    vector<data> tr;
    vector<lazy> lz;

    lazysegtree() {

    }

    lazysegtree(int n) {
        while (siz < n) siz *= 2;
        tr.assign(2 * siz, d_neutral);
        lz.assign(2 * siz, l_neutral);
    }

    void build(int n, int x, int lx, int rx) {
        if (rx - lx == 1) {
            if (lx < n) {
                create(x, lx, rx, 0);
            }

            return;
        }

        int mid = (lx + rx) / 2;

        build(n, 2 * x + 1, lx, mid);
        build(n, 2 * x + 2, mid, rx);

        merge(tr[x], tr[2 * x + 1], tr[2 * x + 2]);
    }

    void build(int n) {
        build(n, 0, 0, siz);
    }

    void rupd(int l, int r, T v, int x, int lx, int rx) {
        propagate(x, lx, rx);

        if (lx >= r or rx <= l) return;
        if (lx >= l and rx <= r) {
            modify(x, lx, rx, v);
            propagate(x, lx, rx);
            return;
        }

        int mid = (lx + rx) / 2;

        rupd(l, r, v, 2 * x + 1, lx, mid);
        rupd(l, r, v, 2 * x + 2, mid, rx);

        merge(tr[x], tr[2 * x + 1], tr[2 * x + 2]);
    }

    void rupd(int l, int r, T v) {
        rupd(l, r + 1, v, 0, 0, siz);
    }

    data query(int l, int r, int x, int lx, int rx) {
        propagate(x, lx, rx);

        if (lx >= r or rx <= l) return d_neutral;
        if (lx >= l and rx <= r) return tr[x];

        int mid = (lx + rx) / 2;

        data curr;
        data left = query(l, r, 2 * x + 1, lx, mid);
        data right = query(l, r, 2 * x + 2, mid, rx);

        merge(curr, left, right);
        return curr;
    }

    data query(int l, int r) {
        return query(l, r + 1, 0, 0, siz);
    }
};

template<typename T>
struct segtree {
    // https://codeforces.com/blog/entry/18051

    /*=======================================================*/

    struct data {
        ll sum,mnp,mns,val1,val2;
    };

    data neutral = {0,0,0,inf2,inf2};

    data merge(data &left, data &right) {
        data curr;

        curr.sum = left.sum+right.sum;
        curr.mnp = min({left.mnp,left.sum+right.mnp});
        curr.mns = min({right.mns,right.sum+left.mns});
        curr.val1 = min({left.val1,curr.mnp});
        curr.val2 = min({right.val2,curr.mns});

        return curr;
    }

    void create(int i, T v) {

    }

    void modify(int i, T v) {
        tr[i] = {v,-v,-v};
    }

    /*=======================================================*/

    int n;
    vector<data> tr;

    segtree() {

    }

    segtree(int siz) {
        init(siz);
    }

    void init(int siz) {
        n = siz;
        tr.assign(2 * n, neutral);
    }

    void build(vector<T> &a, int siz) {
        rep(i, siz) create(i + n, a[i]);
        rev(i, n - 1, 1) tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
    }

    void pupd(int i, T v) {
        modify(i + n, v);
        for (i = (i + n) >> 1; i; i >>= 1) tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
    }

    data query(int l, int r) {
        data resl = neutral, resr = neutral;

        for (l += n, r += n; l <= r; l >>= 1, r >>= 1) {
            if (l & 1) resl = merge(resl, tr[l++]);
            if (!(r & 1)) resr = merge(tr[r--], resr);
        }

        return merge(resl, resr);
    }
};

ll msb(ll x){
    return 63-__builtin_clzll(x);
}

void solve(int test_case)
{
    ll n; cin >> n;
    vector<ll> a(n+5);
    rep1(i,n) cin >> a[i];
    a[0] = a[n+1] = inf2;
    vector<ll> p(n+5);
    rep1(i,n) p[i] = p[i-1]+a[i];

    vector<ll> ngel(n+5), nger(n+5,n+1);

    {
        stack<ll> stk;

        rep1(i,n){
            while(!stk.empty() and a[i] >= a[stk.top()]){
                nger[stk.top()] = i;
                stk.pop();
            }
            stk.push(i);
        }
    }

    {
        stack<ll> stk;

        rev(i,n,1){
            while(!stk.empty() and a[i] >= a[stk.top()]){
                ngel[stk.top()] = i;
                stk.pop();
            }
            stk.push(i);
        }
    }

    set<pll> pairs;

    auto add_pair = [&](ll l, ll r){
        if(l > r) swap(l,r);
        if(r-l-1 <= 0) return;

        ll sum = p[r-1]-p[l];
        if(min(a[l],a[r]) > sum){
            pairs.insert({l+1,r-1});
        }
    };

    rep1(i,n){
        add_pair(i,ngel[i]);
        add_pair(i,nger[i]);
    }

    lazysegtree<ll> st(n+5);
    st.build(n+1);
    for(auto [l,r] : pairs){
        st.rupd(l,r,1);
    }

    segtree<ll> seg(n+5);
    rep1(i,n) seg.pupd(i,a[i]);

    set<ll> pos[30];
    rep1(i,n) pos[msb(a[i])].insert(i);

    auto get = [&](ll i){
        vector<pll> segs;

        // sum[l..i] < a[l-1]
        vector<ll> points_left;
        rep(bit,30){
            auto it = pos[bit].upper_bound(i);
            if(it != pos[bit].begin()){
                it--;
                points_left.pb(*it);
                if(it != pos[bit].begin()){
                    it--;
                    points_left.pb(*it);
                }
            }
        }

        vector<pll> ok_left;
        
        trav(l,points_left){
            if(i == l) conts;
            ll sum = seg.query(l+1,i).sum;
            if(sum < a[l]){
                ok_left.pb({l+1,sum});
            }
            if(l+1 <= i-1 and sum-a[i] < min(a[l],a[i])){
                segs.pb({l+1,i-1});
            }
        }

        ok_left.pb({1,seg.query(1,i).sum});

        // sum[i..r] < a[r+1]
        vector<ll> points_right;
        rep(bit,30){
            auto it = pos[bit].lower_bound(i);
            if(it != pos[bit].end()){
                points_right.pb(*it);
                if(next(it) != pos[bit].end()){
                    points_right.pb(*next(it));
                }
            }
        }

        vector<pll> ok_right;

        trav(r,points_right){
            if(i == r) conts;
            ll sum = seg.query(i,r-1).sum;
            if(sum < a[r]){
                ok_right.pb({r-1,sum});
            }
            if(i+1 <= r-1 and sum-a[i] < min(a[i],a[r])){
                segs.pb({i+1,r-1});
            }
        }

        ok_right.pb({n,seg.query(i,n).sum});

        // merge ok_left, ok_right

        for(auto [l,sum1] : ok_left){
            for(auto [r,sum2] : ok_right){
                ll sum = sum1+sum2-a[i];
                if(sum < min(a[l-1],a[r+1])){
                    segs.pb({l,r});
                }
            }
        }

        // [l..i-1] and [i+1..r] that were not added
        auto &curr = pos[msb(a[i])];
        auto it = curr.find(i);
        if(it != curr.begin()){
            it--;
            if(it != curr.begin()){
                it--;
                ll l = *it+1;
                if(seg.query(l,i-1).sum < min(a[l-1],a[i])){
                    segs.pb({l,i-1});
                }
            }
        }

        it = curr.find(i);
        it++;
        if(it != curr.end()){
            it++;
            if(it != curr.end()){
                ll r = *it-1;
                if(seg.query(i+1,r).sum < min(a[i],a[r+1])){
                    segs.pb({i+1,r});
                }
            }
        }

        return segs;
    };

    ll q; cin >> q;
    while(q--){
        ll t; cin >> t;
        if(t == 1){
            ll i,v; cin >> i >> v;
            auto del = get(i);

            pos[msb(a[i])].erase(i);
            a[i] = v;
            seg.pupd(i,v);
            pos[msb(v)].insert(i);

            auto ins = get(i);

            // debug(i,v);
            // debug(del);
            // debug(ins);
            // cout << endl;

            for(auto [l,r] : del){
                st.rupd(l,r,-1);
            }
            for(auto [l,r] : ins){
                st.rupd(l,r,1);
            }
        }
        else{
            ll l,r; cin >> l >> r;
            ll pos1 = l, pos2 = r;

            {
                ll lo = l, hi = r;
                while(lo <= hi){
                    ll mid = (lo+hi) >> 1;
                    if(seg.query(l,mid-1).sum+seg.query(mid,r).val1 < 0){
                        pos1 = mid;
                        lo = mid+1;
                    }
                    else{
                        hi = mid-1;
                    }
                }
            }

            {
                ll lo = l, hi = r;
                while(lo <= hi){
                    ll mid = (lo+hi) >> 1;
                    if(seg.query(mid+1,r).sum+seg.query(l,mid).val2 < 0){
                        pos2 = mid;
                        hi = mid-1;
                    }
                    else{
                        lo = mid+1;
                    }
                }
            }

            ll ans = st.query(pos1,pos2).cnt;
            cout << ans << endl;
        }
    }
}

int main()
{
    fastio;

    int t = 1;
    // cin >> t;

    rep1(i, t) {
        solve(i);
    }

    return 0;
}

Subtask #1
0 / 5.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Incorrect 7 ms 604 KB Output isn't correct
6 Halted 0 ms 0 KB -

Subtask #2
8.0 / 8.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 604 KB Output is correct
2 Correct 80 ms 27976 KB Output is correct
3 Correct 68 ms 27112 KB Output is correct
4 Correct 81 ms 27996 KB Output is correct
5 Correct 76 ms 27236 KB Output is correct
6 Correct 59 ms 25916 KB Output is correct
7 Correct 44 ms 23884 KB Output is correct
8 Correct 64 ms 25768 KB Output is correct
9 Correct 44 ms 23892 KB Output is correct
10 Correct 58 ms 25232 KB Output is correct
11 Correct 56 ms 24860 KB Output is correct
12 Correct 54 ms 24740 KB Output is correct
13 Correct 52 ms 24916 KB Output is correct
14 Correct 60 ms 27084 KB Output is correct
15 Correct 75 ms 26960 KB Output is correct

Subtask #3
0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Incorrect 7 ms 604 KB Output isn't correct
6 Halted 0 ms 0 KB -

Subtask #4
23.0 / 23.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 604 KB Output is correct
2 Correct 80 ms 27976 KB Output is correct
3 Correct 68 ms 27112 KB Output is correct
4 Correct 81 ms 27996 KB Output is correct
5 Correct 76 ms 27236 KB Output is correct
6 Correct 59 ms 25916 KB Output is correct
7 Correct 44 ms 23884 KB Output is correct
8 Correct 64 ms 25768 KB Output is correct
9 Correct 44 ms 23892 KB Output is correct
10 Correct 58 ms 25232 KB Output is correct
11 Correct 56 ms 24860 KB Output is correct
12 Correct 54 ms 24740 KB Output is correct
13 Correct 52 ms 24916 KB Output is correct
14 Correct 60 ms 27084 KB Output is correct
15 Correct 75 ms 26960 KB Output is correct
16 Correct 1 ms 344 KB Output is correct
17 Correct 780 ms 28968 KB Output is correct
18 Correct 795 ms 30524 KB Output is correct
19 Correct 754 ms 29328 KB Output is correct
20 Correct 789 ms 29064 KB Output is correct
21 Correct 781 ms 29500 KB Output is correct
22 Correct 804 ms 30636 KB Output is correct
23 Correct 789 ms 28940 KB Output is correct
24 Correct 796 ms 29416 KB Output is correct
25 Correct 801 ms 29228 KB Output is correct
26 Correct 818 ms 29504 KB Output is correct
27 Correct 715 ms 27852 KB Output is correct
28 Correct 715 ms 27852 KB Output is correct
29 Correct 730 ms 27724 KB Output is correct
30 Correct 722 ms 25684 KB Output is correct
31 Correct 764 ms 25628 KB Output is correct
32 Correct 768 ms 26664 KB Output is correct
33 Correct 765 ms 27020 KB Output is correct
34 Correct 812 ms 26192 KB Output is correct
35 Correct 785 ms 25552 KB Output is correct
36 Correct 776 ms 27380 KB Output is correct
37 Correct 757 ms 26452 KB Output is correct
38 Correct 678 ms 26420 KB Output is correct
39 Correct 766 ms 28900 KB Output is correct
40 Correct 834 ms 28924 KB Output is correct

Subtask #5
0 / 35.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 604 KB Output is correct
2 Correct 80 ms 27976 KB Output is correct
3 Correct 68 ms 27112 KB Output is correct
4 Correct 81 ms 27996 KB Output is correct
5 Correct 76 ms 27236 KB Output is correct
6 Correct 59 ms 25916 KB Output is correct
7 Correct 44 ms 23884 KB Output is correct
8 Correct 64 ms 25768 KB Output is correct
9 Correct 44 ms 23892 KB Output is correct
10 Correct 58 ms 25232 KB Output is correct
11 Correct 56 ms 24860 KB Output is correct
12 Correct 54 ms 24740 KB Output is correct
13 Correct 52 ms 24916 KB Output is correct
14 Correct 60 ms 27084 KB Output is correct
15 Correct 75 ms 26960 KB Output is correct
16 Correct 0 ms 348 KB Output is correct
17 Incorrect 2379 ms 29284 KB Output isn't correct
18 Halted 0 ms 0 KB -

Subtask #6
0 / 17.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 1 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Incorrect 7 ms 604 KB Output isn't correct
6 Halted 0 ms 0 KB -