洛谷P2572 [SCOI2010] 序列操作(线段树)

题目链接:序列操作

大致题意

给定一个长度为n的01序列, 下标从0开始, 需要实现如下五种操作.

• 0 l r 把 [l, r] 区间内的所有数全变成0
• 1 l r 把 [l, r] 区间内的所有数全变成1
• 2 l r 把 [l, r] 区间内的所有数全部取反，也就是说把所有的0变成1，把所有的1 变成0
• 3 l r 询问 [l, r] 区间内总共有多少个 1
• 4 l r 询问 [l, r] 区间内最多有多少个连续的 1

对于每一种询问操作，需要做出回答.

解题思路

线段树维护序列问题.

考虑到询问操作, 我们应当记录区间内所有1的个数以及连续1的最大长度. 但是考虑到取反操作, 所以我们也当存储对应0的信息. 由于维护连续1的最大长度也需要记录左侧最大连续和右侧最大连续, 因此这里需要记录对应8个信息.

考虑到懒标记, 一个是把区间的所有数字覆盖成全0/1, 另一个是把区间取反. 优先级应是覆盖>取反. 因此对于两种懒标记同时存在的情况, 我们应当优先处理覆盖, 这样就不需要再处理取反标记了. 而对于反转操作, 我们处理后应当考虑其子区间是否存在覆盖操作, 若存在则给覆盖操作取反, 若不存在则下放取反标记.

AC代码

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E5 + 10;
int w[N];
struct node {
    int l, r;
    int fmax[2], lmax[2], rmax[2], sum[2];
    int lazy, flag; //覆盖, 取反
}t[N << 2];
void pushdown(node& op, int lazy, int flag) {
    if (lazy != -1) {
        op.lmax[lazy] = op.rmax[lazy] = op.fmax[lazy] = op.sum[lazy] = op.r - op.l + 1;
        op.lmax[!lazy] = op.rmax[!lazy] = op.fmax[!lazy] = op.sum[!lazy] = 0;
        op.lazy = lazy, op.flag = 0;
    }
    else if (flag) {
        swap(op.fmax[0], op.fmax[1]), swap(op.lmax[0], op.lmax[1]);
        swap(op.rmax[0], op.rmax[1]), swap(op.sum[0], op.sum[1]);
        if (op.lazy != -1) op.lazy ^= 1;
        else op.flag ^= 1;
    }
}
void pushdown(int x) {
    if (t[x].lazy == -1 && !t[x].flag) return;
    pushdown(t[x << 1], t[x].lazy, t[x].flag);
    pushdown(t[x << 1 | 1], t[x].lazy, t[x].flag);
    t[x].lazy = -1, t[x].flag = 0;
}

void pushup(node& p, node& l, node& r) {
    int lsize = l.r - l.l + 1, rsize = r.r - r.l + 1;
    for (int i = 0; i < 2; ++i) {
        p.fmax[i] = max(max(l.fmax[i], r.fmax[i]), l.rmax[i] + r.lmax[i]);
        p.lmax[i] = l.lmax[i] + (l.lmax[i] == lsize ? r.lmax[i] : 0);
        p.rmax[i] = r.rmax[i] + (r.rmax[i] == rsize ? l.rmax[i] : 0);
        p.sum[i] = l.sum[i] + r.sum[i];
    }
}
void pushup(int x) { pushdown(x); pushup(t[x], t[x << 1], t[x << 1 | 1]); }

void build(int l, int r, int x = 1) {
    t[x] = { l, r }; t[x].lazy = -1;
    if (l == r) {
        int k = w[l];
        t[x].fmax[k] = t[x].lmax[k] = t[x].rmax[k] = t[x].sum[k] = 1;
        return;
    }
    
    int mid = l + r >> 1;
    build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
    pushup(x);
}

void modify(int l, int r, int lazy, int flag, int x = 1) {
    if (l <= t[x].l && r >= t[x].r) {
        pushdown(t[x], lazy, flag);
        return;
    }
    pushdown(x);
    int mid = t[x].l + t[x].r >> 1;
    if (l <= mid) modify(l, r, lazy, flag, x << 1);
    if (r > mid) modify(l, r, lazy, flag, x << 1 | 1);
    pushup(x);
}

node ask(int l, int r, int x = 1) {
    if (l <= t[x].l && r >= t[x].r) return t[x];
    pushdown(x);
    int mid = t[x].l + t[x].r >> 1;
    if (r <= mid) return ask(l, r, x << 1);
    if (l > mid) return ask(l, r, x << 1 | 1);
    node res, left = ask(l, r, x << 1), right = ask(l, r, x << 1 | 1);
    pushup(res, left, right);
    return res;
}

int main()
{
    int n, m; cin >> n >> m;
    rep(i, n) scanf("%d", &w[i]);
    build(1, n);
    
    while (m--) {
        int k, l, r; scanf("%d %d %d", &k, &l, &r); l++, r++; //从0开始的下标映射为从1开始
        if (k == 0) modify(l, r, 0, 0);
        else if (k == 1) modify(l, r, 1, 0);
        else if (k == 2) modify(l, r, -1, 1);
        else if (k == 3) printf("%d\n", ask(l, r).sum[1]);
        else if (k == 4) printf("%d\n", ask(l, r).fmax[1]);
    }
    return 0;
}

END