SHOI2015 脑洞治疗仪

以前就这道题跟大佬讨论过，我觉得就是暴力填充，他说二分位置填充，后来发现我的方法麻烦到了极点...果断二分，还是打了6K......

题意：有个01序列，要求支持以下操作:

1.区间赋0

2.区间求和

3.把区间内前k个0变成1

一看就是线段树...

操作三只需要二分求出位置即可。

总复杂度nlog²n，最慢的点卡着0.92s过了。

#include <cstdio>
#include <algorithm>
const int N = 200010;

struct SegmentTree {
    int sum[N << 2], left[N << 2], right[N << 2], large[N << 2], tag[N << 2];

    inline void pushup(int l, int r, int o) {
        if(l == r) {
            left[o] = right[o] = large[o] = sum[o] ^ 1;
            return;
        }
        int mid = (l + r) >> 1;
        int ls = o << 1;
        int rs = ls | 1;

        sum[o] = sum[ls] + sum[rs];
        large[o] = std::max(large[ls], large[rs]);
        large[o] = std::max(large[o], left[rs] + right[ls]);
        if(!sum[ls]) {
            left[o] = mid - l + 1 + left[rs];
        }
        else {
            left[o] = left[ls];
        }
        if(!sum[rs]) {
            right[o] = r - mid + right[ls];
        }
        else {
            right[o] = right[rs];
        }
        return;
    }
    inline void pushdown(int l, int r, int o) {
        if(l == r) {
            return;
        }
        int mid = (l + r) >> 1;
        int ls = o << 1;
        int rs = ls | 1;
        if(tag[o] == 1) {
            sum[ls] = mid - l + 1;
            sum[rs] = r - mid;
            tag[ls] = tag[rs] = 1;
            left[ls] = left[rs] = 0;
            right[ls] = right[rs] = 0;
            large[ls] = large[rs] = 0;
        }
        else if(!tag[o]) {
            sum[ls] = sum[rs] = 0;
            tag[ls] = tag[rs] = 0;
            left[ls] = right[ls] = large[ls] = mid - l + 1;
            left[rs] = right[rs] = large[rs] = r - mid;
        }
        tag[o] = -1;
        return;
    }
    void cancel(int L, int R, int l, int r, int o) {
        if(L <= l && r <= R) {
            tag[o] = sum[o] = 0;
            left[o] = right[o] = large[o] = r - l + 1;
            return;
        }
        pushdown(l, r, o);
        int mid = (l + r) >> 1;
        if(L <= mid) {
            cancel(L, R, l, mid, o << 1);
        }
        if(mid < R) {
            cancel(L, R, mid + 1, r, o << 1 | 1);
        }
        pushup(l, r, o);
        return;
    }
    int getsum(int L, int R, int l, int r, int o) {
        if(L <= l && r <= R) {
            return sum[o];
        }
        if(r < L || R < l) {
            return 0;
        }
        pushdown(l, r, o);
        int mid = (l + r) >> 1;
        return getsum(L, R, l, mid, o << 1) + getsum(L, R, mid + 1, r, o << 1 | 1);
    }
    void add(int L, int R, int l, int r, int o) {
        pushdown(l, r, o);
        if(L <= l && r <= R) {
            tag[o] = 1;
            sum[o] = r - l + 1;
            left[o] = right[o] = large[o] = 0;
            return;
        }
        int mid = (l + r) >> 1;
        if(L <= mid) {
            add(L, R, l, mid, o << 1);
        }
        if(mid < R) {
            add(L, R, mid + 1, r, o << 1 | 1);
        }
        pushup(l, r, o);
        return;
    }
    void ask(int L, int R, int l, int r, int o, int &la, int &ra, int &ans) {
        pushdown(l, r, o);
        if(L == l && r == R) {
            la = left[o];
            ra = right[o];
            ans = large[o];
            return;
        }
        int mid = (l + r) >> 1;
        int ls = o << 1;
        int rs = ls | 1;
        if(R <= mid) {
            ask(L, R, l, mid, ls, la, ra, ans);
            return;
        }
        if(mid < L) {
            ask(L, R, mid + 1, r, rs, la, ra, ans);
            return;
        }
        int A = -1;
        int B = A, C = A, D = A, E = A, F = A;
        if(L != l && r != R) {
            ask(L, mid, l, mid, ls, A, B, C);
            ask(mid + 1, R, mid + 1, r, rs, D, E, F);
            ans = std::max(C, F);
            ans = std::max(ans, B + D);
            return;
        }
        if(R == r) {
            ask(L, mid, l, mid, ls, A, B, C);
            ans = std::max(large[rs], C);
            ans = std::max(ans, B + left[rs]);
            if(!sum[rs]) {
                ra = r - mid + B;
            }
            else {
                ra = right[rs];
            }
            return;
        }
        if(L == l) {
            ask(mid + 1, R, mid + 1, r, rs, A, B, C);
            ans = std::max(large[ls], C);
            ans = std::max(ans, right[ls] + A);
            if(!sum[ls]) {
                la = mid - l + 1 + A;
            }
            else {
                la = left[ls];
            }
            return;
        }
        printf("ERROR! ");
        return;
    }
    void build(int l, int r, int o) {
        tag[o] = -1;
        if(l == r) {
            sum[o] = 1;
            left[o] = right[o] = large[o] = 0;
            return;
        }
        int mid = (l + r) >> 1;
        build(l, mid, o << 1);
        build(mid + 1, r, o << 1 | 1);
        pushup(l, r, o);
        return;
    }
}T;

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    T.build(1, n, 1);
    int x, y, xx, yy, f;
    while(m--) {
        scanf("%d%d%d", &f, &x, &y);
        if(!f) {
            T.cancel(x, y, 1, n, 1);
        }
        else if(f == 2) {
            int ans;
            T.ask(x, y, 1, n, 1, xx, yy, ans);
            printf("%d\n", ans);
        }
        else {
            scanf("%d%d", &xx, &yy);
            int t = T.getsum(x, y, 1, n, 1);
            T.cancel(x, y, 1, n, 1);
            if(t >= yy - xx + 1 - T.getsum(xx, yy, 1, n, 1)) {
                T.add(xx, yy, 1, n, 1);
                continue;
            }
            if(!t) {
                continue;
            }
            int l = xx + t - 1, r = yy - 1, mid;
            while(l < r) {
                mid = (l + r) >> 1;
                //printf("getsum %d %d : %d \n", xx, mid, T.getsum(xx, mid, 1, n, 1));
                if(mid - xx + 1 - T.getsum(xx, mid, 1, n, 1) < t) {
                    l = mid + 1;
                }
                else {
                    r = mid;
                }
            }
            //printf("t = %d \n add: %d %d \n", t, xx, r);
            T.add(xx, r, 1, n, 1);
        }
    }

    return 0;
}