P2572 [SCOI2010]序列操作

对自己 & \(RNG\) ： 骄兵必败
\(lpl\)加油！

P2572 [SCOI2010]序列操作

题目描述
lxhgww最近收到了一个01序列，序列里面包含了n个数，这些数要么是0，要么是1，现在对于这个序列有五种变换操作和询问操作：

0 a b 把[a, b]区间内的所有数全变成0

1 a b 把[a, b]区间内的所有数全变成1

2 a b 把[a,b]区间内的所有数全部取反，也就是说把所有的0变成1，把所有的1变成0

3 a b 询问[a, b]区间内总共有多少个1

4 a b 询问[a, b]区间内最多有多少个连续的1

对于每一种询问操作，lxhgww都需要给出回答，聪明的程序员们，你们能帮助他吗？


错误日志： 内容较多且重要， 将写在下方加粗

Solution

线段树， 需要维护以下信息：

  1. \(sum\) 区间 \(1\) 的个数
  2. \(max[0/1]\) 区间内 \(0/1\) 最长连续子段
  3. \(lmax[0/1]\) 包含区间左端点最长 \(0/1\) 子段
  4. \(rmax[0/1]\) 包含区间右端点最长 \(0/1\) 子段

鉴于有区间操作， 这里还需要两个标记：

  1. \(lazy = {-1, 0, 1}\) 为 \(-1\) 表示无状态， 为 \(0/1\) 表示区间全部赋值为 \(0/1\)
  2. \(rev = {0, 1}\) 区间是否翻转

需要维护的元素较多， 先讲 \(pushup\)
区间和直接相加即可
包含左端点的连续子段有两种情况：

  1. 直接继承左区间的 \(lmax\)
  2. 当左区间全满 / 全空时， 左端点可以跨越， 加上右区间的部分

右区间更新同理

对于区间最长连续子段， 有以下三种情况

  1. 直接继承左区间的较大值
  2. 直接继承右区间的较大值
  3. 左区间的含右端点最长子段 + 右区间含左端点最长子段， 即最长部分跨越区间分割线

以上需要分 \(0/1\) 讨论， 程序中直接两层循环搞定


然后到了难点 \(pushdown\)
我一个需要冲省队的选手竟然直到现在才注意到这点很惨啊
在线段树 \(pushdown\) 操作中， 我们需要明确两件事：

  1. 标记的优先级
    2. 下放某一标记是否会对子节点的其他类型标记有所影响

这里重点讨论第二点（第一点区间全体赋值优先级肯定高于翻转， 所以优先拆区间赋值标记， 拆标记时需要将翻转标记清空）
在拆解一个标记时， 我们不仅需要明确将此标记下放到子节点， 同类型的标记应该如何改变， 而更应明确拆解此标记会对 不同类型的标记有何种影响
明确同类型的影响是一般不会出问题的， 如将区间加标记下放时， 子节点的区间加标记累加上这个值

以本题为例：
将区间赋值标记拆解时， 不仅需要将子区间赋值标记更新为此值， 还需要将子节点翻转标记清空（不过这个貌似影响不大， 拆赋值标记时会将翻转标记清空的）
将区间翻转标记拆解时， 需要分两种情况考虑此标记下推对子区间 赋值标记 和 翻转标记造成的影响
考虑到赋值标记的优先级大于翻转标记， 在有赋值标记的情况下， 直接翻转赋值标记
其余情况翻转标记异或等于1


其余见代码 虽然很长但用心弄懂会对线段树有一个很深刻的理解

这样完备地考虑所有情况是一个 \(OI\) 选手的基本素养


嗯就这样， \(RNG\) 别丧气， 你们是最棒的； \(S8\) ，\(lpl\) 加油！

Code

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#include<climits>
#define LL long long
#define REP(i, x, y) for(int i = (x);i <= (y);i++)
using namespace std;
int RD(){
    int out = 0,flag = 1;char c = getchar();
    while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
    while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
    return flag * out;
    }
const int maxn = 200019;
int num, na;
int v[maxn];
#define lid (id << 1)
#define rid (id << 1) | 1
//int max(int a, int b){return a > b ? a : b;}//听说手写快？
struct seg_tree{
    int l, r;
    int sum;
    int lazy;//-1.NULL  0.全为0  1.全为1
    int rev;
    int max[2], lmax[2], rmax[2];
    }tree[maxn << 2];
void pushup(int id){
    tree[id].sum = tree[lid].sum + tree[rid].sum;
    REP(i, 0, 1){
        tree[id].lmax[i] = tree[lid].lmax[i];
        if(i == 1 && tree[lid].sum == tree[lid].r - tree[lid].l + 1)//左区间全满
            tree[id].lmax[i] += tree[rid].lmax[i];//可以跨越
        else if(i == 0 && tree[lid].sum == 0)//左区间全空
            tree[id].lmax[i] += tree[rid].lmax[i];

        tree[id].rmax[i] = tree[rid].rmax[i];
        if(i == 1 && tree[rid].sum == tree[rid].r - tree[rid].l + 1)
            tree[id].rmax[i] += tree[lid].rmax[i];
        else if(i == 0 && tree[rid].sum == 0)
            tree[id].rmax[i] += tree[lid].rmax[i];

        tree[id].max[i] = tree[lid].rmax[i] + tree[rid].lmax[i];//中间
        tree[id].max[i] = max(tree[id].max[i], tree[lid].max[i]);//继承子区间
        tree[id].max[i] = max(tree[id].max[i], tree[rid].max[i]);
        }
    }
void build(int id, int l, int r){
    tree[id].l = l, tree[id].r = r, tree[id].lazy = -1;
    if(l == r){
        tree[id].sum = v[l];
        tree[id].max[0] = tree[id].lmax[0] = tree[id].rmax[0] = v[l] == 0;
        tree[id].max[1] = tree[id].lmax[1] = tree[id].rmax[1] = v[l] == 1;
        return ;
        }
    int mid = (l + r) >> 1;
    build(lid, l, mid), build(rid, mid + 1, r);
    pushup(id);
    }
void pushdown(int id){
    if(tree[id].lazy != -1){//优先级最高
        tree[id].rev = 0;//清空标记
        int val = tree[id].lazy;
        tree[lid].sum = (tree[lid].r - tree[lid].l + 1) * val;
        tree[rid].sum = (tree[rid].r - tree[rid].l + 1) * val;

        tree[lid].lazy = tree[rid].lazy = val;
        tree[lid].rev = tree[rid].rev = 0;

        tree[lid].max[val]
        = tree[lid].lmax[val]
        = tree[lid].rmax[val]
        = tree[lid].r - tree[lid].l + 1;
        tree[lid].max[val ^ 1]
        = tree[lid].lmax[val ^ 1]
        = tree[lid].rmax[val ^ 1]
        = 0;

        tree[rid].max[val]
        = tree[rid].lmax[val]
        = tree[rid].rmax[val]
        = tree[rid].r - tree[rid].l + 1;
        tree[rid].max[val ^ 1]
        = tree[rid].lmax[val ^ 1]
        = tree[rid].rmax[val ^ 1]
        = 0;

        tree[id].lazy = -1;
        }
    if(tree[id].rev){
        tree[lid].sum = (tree[lid].r - tree[lid].l + 1) - tree[lid].sum;
        tree[rid].sum = (tree[rid].r - tree[rid].l + 1) - tree[rid].sum;

        if(tree[lid].lazy != -1)tree[lid].lazy ^= 1;//综合考虑优先级， 对其他标记的影响
        else tree[lid].rev ^= 1;
        if(tree[rid].lazy != -1)tree[rid].lazy ^= 1;
        else tree[rid].rev ^= 1;

        swap(tree[lid].max[0], tree[lid].max[1]);
        swap(tree[lid].lmax[0], tree[lid].lmax[1]);
        swap(tree[lid].rmax[0], tree[lid].rmax[1]);

        swap(tree[rid].max[0], tree[rid].max[1]);
        swap(tree[rid].lmax[0], tree[rid].lmax[1]);
        swap(tree[rid].rmax[0], tree[rid].rmax[1]);

        tree[id].rev = 0;
        }
    }
void update(int id, int val, int l, int r){
    pushdown(id);
    if(tree[id].l == l && tree[id].r == r){
        if(val == 0 || val == 1){
            tree[id].sum = (tree[id].r - tree[id].l + 1) * val;
            tree[id].lazy = val;
            tree[id].max[val]
            = tree[id].lmax[val]
            = tree[id].rmax[val]
            = tree[id].r - tree[id].l + 1;
            tree[id].max[val ^ 1]
            = tree[id].lmax[val ^ 1]
            = tree[id].rmax[val ^ 1]
            = 0;
            }
        else if(val == 2){
            tree[id].sum = (tree[id].r - tree[id].l + 1) - tree[id].sum;
            tree[id].rev ^= 1;
            swap(tree[id].max[0], tree[id].max[1]);
            swap(tree[id].lmax[0], tree[id].lmax[1]);
            swap(tree[id].rmax[0], tree[id].rmax[1]);
            }
        return ;
        }
    int mid = (tree[id].l + tree[id].r) >> 1;
    if(mid < l)update(rid, val, l, r);
    else if(mid >= r)update(lid, val, l, r);
    else update(lid, val, l, mid), update(rid, val, mid + 1, r);
    pushup(id);
    }
int query(int id, int l, int r){
    pushdown(id);
    if(tree[id].l == l && tree[id].r == r)return tree[id].sum;
    int mid = (tree[id].l + tree[id].r) >> 1;
    if(mid < l)return query(rid, l, r);
    else if(mid >= r)return query(lid, l, r);
    else return query(lid, l, mid) + query(rid, mid + 1, r);
    }
seg_tree Q_max(int id, int l, int r){
    pushdown(id);
    if(tree[id].l == l && tree[id].r == r)return tree[id];
    int mid = (tree[id].l + tree[id].r) >> 1;
    if(mid < l)return Q_max(rid, l, r);
    else if(mid >= r)return Q_max(lid, l, r);
    else{
        seg_tree ret, L = Q_max(lid, l, mid), R = Q_max(rid, mid + 1, r);
        ret.sum = L.sum + R.sum;
        REP(i, 0, 1){
            ret.lmax[i] = L.lmax[i];
            if(i == 1 && L.sum == L.r - L.l + 1)//左区间全满
                ret.lmax[i] += R.lmax[i];//可以跨越
            else if(i == 0 && L.sum == 0)//左区间全空
                ret.lmax[i] += R.lmax[i];

            ret.rmax[i] = R.rmax[i];
            if(i == 1 && R.sum == R.r - R.l + 1)
                ret.rmax[i] += L.rmax[i];
            else if(i == 0 && R.sum == 0)
                ret.rmax[i] += L.rmax[i];

            ret.max[i] = L.rmax[i] + R.lmax[i];//中间
            ret.max[i] = max(ret.max[i], L.max[i]);//继承子区间
            ret.max[i] = max(ret.max[i], R.max[i]);
            }
        return ret;
        }
    }
int main(){
    num = RD(), na = RD();
    REP(i, 1, num)v[i] = RD();
    build(1, 1, num);
    while(na--){
        int cmd = RD(), l = RD(), r = RD();l++, r++;
        if(cmd == 0)update(1, 0, l, r);
        else if(cmd == 1)update(1, 1, l, r);
        else if(cmd == 2)update(1, 2, l, r);
        else if(cmd == 3)printf("%d\n", query(1, l, r));
        else printf("%d\n", Q_max(1, l, r).max[1]);
        }
    return 0;
    }

原文地址：https://www.cnblogs.com/Tony-Double-Sky/p/9823463.html

时间： 2024-10-09 11:53:34

P2572 [SCOI2010]序列操作的相关文章

【题解】Luogu P2572 [SCOI2010]序列操作

原题传送门:P2572 [SCOI2010]序列操作 这题好弱智啊 裸的珂朵莉树 前置芝士:珂朵莉树 窝博客里对珂朵莉树的介绍 没什么好说的自己看看吧 操作1:把区间内所有数推平成0,珂朵莉树基本操作 操作2:把区间内所有数推平成1,珂朵莉树基本操作 操作3:把区间内所有数取反(异或1),split后扫描一遍,值域取反 操作4:区间和,珂朵莉树基本操作 操作5:区间最长连续的1,暴力扫描累加 就是这样简单 好像跑的比线段树还快???喵喵喵 #pragma GCC optimize("O3&quo

bzoj 1858: [Scoi2010] 序列操作 题解

[原题] 1858: [Scoi2010]序列操作 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 1031  Solved: 529 [Submit][Status] Description lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要么是1,现在对于这个序列有五种变换操作和询问操作: 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区间内

1858: [Scoi2010]序列操作

1858: [Scoi2010]序列操作 Description lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要么是1,现在对于这个序列有五种变换操作和询问操作: 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区间内的所有数全部取反,也就是说把所有的0变成1,把所有的1变成0 3 a b 询问[a, b]区间内总共有多少个1 4 a b 询问[a, b]区间内最多有多少个连续的1 对于每一

【BZOJ 1858】 [Scoi2010]序列操作

1858: [Scoi2010]序列操作 Time Limit: 10 Sec Memory Limit: 64 MB Submit: 1368 Solved: 712 [Submit][Status][Discuss] Description lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要么是1,现在对于这个序列有五种变换操作和询问操作: 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区

bzoj 1858: [Scoi2010]序列操作

1858: [Scoi2010]序列操作 Time Limit: 10 Sec  Memory Limit: 64 MB 线段树,对于每个区间需要分别维护左右中的1和0连续个数,并在op=4时特殊处理一下. Description lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要么是1,现在对于这个序列有五种变换操作和询问操作: 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区间内的所有数全

bzoj 1858: [Scoi2010]序列操作 || 洛谷 P2572

记一下:线段树占空间是$2^{ceil(log2(n))+1}$ 这个就是一个线段树区间操作题,各种标记的设置.转移都很明确,只要熟悉这类题应该说是没有什么难度的. 由于对某区间set之后该区间原先待进行的取反操作失效(被覆盖),因此规定tag同时存在时set的标记先进行操作,这样对区间加上set标记时要去掉原有的取反标记. 对于操作4,线段树上每个区间维护6个值,分别表示:该区间最多的连续0/1,从左侧数起/从右侧数起/其中任意位置.题目中不问连续0,为什么连续0也要维护呢?这是为了在进行取反

BZOJ 1858 SCOI2010 序列操作 线段树

题目大意:给定一个01序列,提供三种操作: 0:把一段区间的全部元素都变成0 1:把一段区间的全部元素都变成1 2:把一段区间内的全部元素全都取反 3:查询一段区间内1的个数 4:查询一段区间内最长的一段连续的1 首先假设没有操作4这就是bitset的水题... 多了这个,我们考虑线段树 线段树的每个节点存改动标记和翻转标记,以及该区间的信息 尽管查询的信息都是1 可是我们要连0一起保存 由于翻转后0就变成了1 1就变成了0 区间信息包含: 左端点的元素 右端点的元素 左端点開始的最长的连续元素

BZOJ1858[Scoi2010]序列操作 题解

题目大意: 有一个01序列,现在对于这个序列有五种变换操作和询问操作: 0 a b 把[a, b]区间内的所有数全变成0:1 a b 把[a, b]区间内的所有数全变成1:2 a b 把[a,b]区间内的所有数全部取反,也就是说把所有的0变成1,把所有的1变成0:3 a b 询问[a, b]区间内总共有多少个1:4 a b 询问[a, b]区间内最多有多少个连续的1. 思路: 维护每一段数的和.左端和右端以及整段中连续的0和1的长度,并使用标记进行下传. 代码: 1 #include<cstdi

BZOJ_1858_[Scoi2010]序列操作_线段树

Description lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要么是1,现在对于这个序列有五种变换操作和询问操作: 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区间内的所有数全部取反,也就是说把所有的0变成1,把所有的1变成0 3 a b 询问[a, b]区间内总共有多少个1 4 a b 询问[a, b]区间内最多有多少个连续的1 对于每一种询问操作,lxhgww都需要给出回答,聪