省队集训 Day6 序列

【题目大意】

给出$n$个数的序列$a_1, a_2, ..., a_n$，有$m$次操作，为下面三种：

$A~l~r~d$：区间$[l,r]$，全部加$d$。

$M~l~r~d$：区间$[l,r]$，对$d$取max。

$Q~x$：询问$a_x$的值。

对于30%的数据，$n, m\leq 10^4$；

对于60%的数据，保证数据随机；

对于100%的数据，满足$n, m \leq 10^5$，所有数的绝对值不超过$2^{31} - 1$。保证也是随机的。

【题解】

显然正解是吉司机线段树，我不会，那怎么办？分块！！！

对于100%的数据的那个性质我是拿数据后才知道的。

考场写了$O(n * (n/B) * logB)$的常数大的跟*一样的分块做法，其中$B = 32$，理论上$B = 128$左右比较优，可能是我常数太大了只能开32。。。

由于数据随机（迷），就过了……

具体是这样的，每个操作如果涉及部分块，直接暴力重构。

每个块内排序后，发现操作2相当于找一段前缀，改成$d$，然后将这些数的次数全部+1，这个可以方便用线段树维护，找的话线段树上二分即可。

操作1的话相当于块全局加，然后这些块的次数全部+1（需要特判$d=0$），可以记录一个全局标记来做。

然后就很方便维护信息了（吧），为了线段树上二分可能需要记录一个最小值。

然后调调边界啊，开开longlong啊，卡了卡常就过了。。

# include <stdio.h>
# include <assert.h>
# include <string.h>
# include <iostream>
# include <algorithm>
# define getchar getchar_unlocked

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

# ifdef WIN32
# define LLFORMAT "%I64d"
# else
# define LLFORMAT "%lld"
# endif

# define beg BEG
# define end END

const int N = 1e5 + , B = , SN =  + ;
const ll inf = 1e17;

inline int getint() {
    int x = , f = ; char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') f = ;
        ch = getchar();
    }
    while(isdigit(ch)) x = (x<<) + (x<<) + ch - '', ch = getchar();
    return f ? x : -x;
}

int n, m, beg[B], end[B], len[B], bl[N], id[B][];

struct pa {
    ll a; int t;
    pa() {}
    pa(ll a, int t) : a(a), t(t) {}
    inline friend bool operator < (pa a, pa b) {
        return a.a < b.a;
    }
    inline friend pa operator + (pa a, pa b) {
        return pa(min(a.a, b.a), );
    }
}p[N];

pa g[B]; int gn = ;
ll add[B]; int addt[B];
struct SMT {
    // 区间覆盖，对于a做，区间加法，对于t做
    pa w[SN]; int tag[SN]; ll cov[SN]; bool hc[SN];
    # define ls (x<<)
    # define rs (x<<|)
    inline void up(int x) {
        w[x] = w[ls] + w[rs];
    }
    inline void pushtag(int x, int tg) {
        tag[x] += tg; w[x].t += tg;
    }
    inline void pushcov(int x, ll c) {
        w[x].a = c; cov[x] = c; hc[x] = ;
    }
    inline void down(int x) {
        if(hc[x]) {
            pushcov(ls, cov[x]); pushcov(rs, cov[x]);
            hc[x] = ; cov[x] = ;
        }
        if(tag[x]) {
            pushtag(ls, tag[x]); pushtag(rs, tag[x]);
            tag[x] = ;
        }
    }
    inline void build(int x, int l, int r) {
        tag[x] = cov[x] = ; hc[x] = ;
        if(l == r) {
            w[x] = g[l];
            return ;
        }
        int mid = l+r>>;
        build(ls, l, mid); build(rs, mid+, r);
        up(x);
    }
    inline void cover(int x, int l, int r, int L, int R, ll p) {
        if(L <= l && r <= R) {
            pushcov(x, p);
            pushtag(x, );
            return ;
        }
        down(x);
        int mid = l+r>>;
        if(L <= mid) cover(ls, l, mid, L, R, p);
        if(R > mid) cover(rs, mid+, r, L, R, p);
        up(x);
    }
    inline void gans(int x, int l, int r) {
        if(l == r) {
            g[++gn] = w[x];
            return ;
        }
        down(x);
        int mid = l+r>>;
        gans(ls, l, mid); gans(rs, mid+, r);
    }
    inline pa gs(int x, int l, int r, int ps) {
//        cerr << x << ' ' << w[x].a << ' ' << w[x].t << endl;
        if(l == r) return w[x];
        down(x);
        int mid = l+r>>;
        if(ps <= mid) return gs(ls, l, mid, ps);
        else return gs(rs, mid+, r, ps);
    }
    // find the last number that < p
    inline int find(int x, int l, int r, ll p) {
        if(l == r) return l;
        down(x);
        int mid = l+r>>;
        if(w[rs].a < p) return find(rs, mid+, r, p);
        else return find(ls, l, mid, p);
    }

    inline void debug(int x, int l, int r) {
        printf("x = %d, min = " LLFORMAT "\n", x, w[x].a);
        if(l == r) {
            printf("  times = %d\n", w[x].t);
            return ;
        }
        int mid = l+r>>;
        debug(ls, l, mid);
        debug(rs, mid+, r);
    }
    # undef ls
    # undef rs
}T[B];

int tid[B];
inline bool cmp(int x, int y) {
    return p[x] < p[y];
}

namespace prepare {
    inline void deal(int x) {
        register int *pid = id[x], Len; Len = len[x] = end[x] - beg[x] + ;
        for (register int i=; i<=Len; ++i) tid[i] = beg[x] + i - ;
        sort(tid+, tid+Len+, cmp);
        for (register int i=; i<=Len; ++i) g[i] = p[tid[i]];
        T[x].build(, , Len);
        for (register int i=; i<=Len; ++i) pid[i] = tid[i];
    }
}

namespace option1 {
    inline void deal(int x, int l, int r, int c) {
        register int *pid = id[x], Len = len[x];
        gn = , T[x].gans(, , Len);
        for (register int i=; i<=Len; ++i) p[pid[i]] = g[i], tid[i] = beg[x] + i - ;
        for (register int i=beg[x]; i<=end[x]; ++i) p[i].a += add[x], p[i].t += addt[x];
        add[x] = ; addt[x] = ;
        for (register int i=l; i<=r; ++i) p[i].a += c, p[i].t ++;
        sort(tid+, tid+Len+, cmp);
        for (register int i=; i<=Len; ++i) g[i] = p[tid[i]];
        T[x].build(, , Len);
        for (register int i=; i<=Len; ++i) pid[i] = tid[i];
    }
    inline void deal(int x, int c) {
        add[x] += c; addt[x] ++;
    }
    inline void main(int l, int r, int c) {
        register int L = bl[l], R = bl[r];
        if(L == R) deal(L, l, r, c);
        else {
            deal(L, l, end[L], c);
            deal(R, beg[R], r, c);
            for (register int i=L+; i<R; ++i) deal(i, c);
        }
    }
}

namespace option2 {
    inline void deal(int x, int l, int r, int c) {
        register int *pid = id[x], Len = len[x];
        gn = , T[x].gans(, , Len);
        for (register int i=; i<=Len; ++i) p[pid[i]] = g[i], tid[i] = beg[x] + i - ;
        for (register int i=beg[x]; i<=end[x]; ++i) p[i].a += add[x], p[i].t += addt[x];
        add[x] = ; addt[x] = ;
        for (register int i=l; i<=r; ++i)
            if(p[i].a < c) p[i].a = c, p[i].t ++;
        sort(tid+, tid+Len+, cmp);
        for (register int i=; i<=Len; ++i) g[i] = p[tid[i]];
//        for (int i=1; i<=len[x]; ++i) cerr << g[i].a << ' ' << g[i].t << " ====\n";
        T[x].build(, , Len);
        for (register int i=; i<=Len; ++i) pid[i] = tid[i];
//        for (int i=1; i<=len[x]; ++i) cerr << id[x][i] << ' '; cout << "  id end\n";
    }
    inline void deal(int x, int c) {
        ll p = c - add[x];
        if(T[x].w[].a >= p) return ;
        else {
            int tp = T[x].find(, , len[x], p);
            T[x].cover(, , len[x], , tp, p);
        }
    }
    inline void main(int l, int r, int c) {
        register int L = bl[l], R = bl[r];
        if(L == R) deal(L, l, r, c);
        else {
            deal(L, l, end[L], c);
            deal(R, beg[R], r, c);
            for (register int i=L+; i<R; ++i) deal(i, c);
        }
    }
}

namespace option3 {
    inline pa main(int x) {
        register int X = bl[x], *pid = id[X]; pa ret = pa(-inf, );
        for (register int i=; i<=len[X]; ++i)
            if(pid[i] == x) {
                ret = T[X].gs(, , len[X], i);
                break;
            }
        if(ret.a != -inf) ret.a += add[X];
        ret.t += addt[X];
        return ret;
    }
}

int main() {
    freopen("seq4.in", "r", stdin);
    freopen("seq.out", "w", stdout);
    const int BB = ;
    n = getint();
    for (register int i=; i<=n; ++i) p[i] = pa(getint(), );
    for (register int i=; i<=n; ++i) bl[i] = (i-)/BB + ;
    m = bl[n];
    for (register int i=; i<=m; ++i) beg[i] = (i-)*BB+, end[i] = i*BB; end[m] = n;
    for (register int i=; i<=m; ++i) prepare :: deal(i);
    int Q = getint();
    static int l, r, c;
    static char ch;
    pa t;
    while(Q--) {
        ch = getchar();
        while(!isupper(ch)) ch = getchar();
//        T[1].debug(1, 1, len[1]);
//        for (int i=1; i<=len[1]; ++i) cout << id[1][i] << ' '; cout << endl;
        if(ch == 'A') {
            l = getint(), r = getint(), c = getint();
            if(!c) continue;
            option1 :: main(l, r, c);
        } else if(ch == 'M') {
            l = getint(), r = getint(), c = getint();
            option2 :: main(l, r, c);
        } else {
            l = getint();
            t = option3 :: main(l);
            printf(LLFORMAT " %d\n", t.a, t.t);
        }
    }
    return ;
}