hdoj 3397 Sequence operation 【线段树区间覆盖 + 异或 + 合并】【维护延迟标记的顺序】

最新推荐文章于 2022-07-28 21:10:58 发布

笑着走完自己的路

最新推荐文章于 2022-07-28 21:10:58 发布

阅读量810

点赞数

分类专栏：线段树

本文链接：https://blog.csdn.net/chenzhenyu123456/article/details/48735709

版权

线段树专栏收录该内容

59 篇文章 0 订阅

订阅专栏

Sequence operation

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7238 Accepted Submission(s): 2165

Problem Description

lxhgww got a sequence contains n characters which are all '0's or '1's.
We have five operations here:
Change operations:
0 a b change all characters into '0's in [a , b]
1 a b change all characters into '1's in [a , b]
2 a b change all '0's into '1's and change all '1's into '0's in [a, b]
Output operations:
3 a b output the number of '1's in [a, b]
4 a b output the length of the longest continuous '1' string in [a , b]

Input

T(T<=10) in the first line is the case number.
Each case has two integers in the first line: n and m (1 <= n , m <= 100000).
The next line contains n characters, '0' or '1' separated by spaces.
Then m lines are the operations:
op a b: 0 <= op <= 4 , 0 <= a <= b < n.

Output

For each output operation , output the result.

Sample Input

      
      
       
       1
10 10
0 0 0 1 1 0 1 0 1 1
1 0 2
3 0 5
2 2 2
4 0 4
0 3 6
2 3 7
4 2 8
1 0 5
0 5 6
3 3 9

Sample Output

憋了一个小时，终于用两种查询方式AC了。 \(^o^)/~

题意：给你n个数和q次查询。查询有5种：

一、0 a b —— 表示把区间[a, b]之间的数全变为0；

二、1 a b —— 表示把区间[a, b]之间的数全变为1；

三、2 a b —— 表示把区间[a, b]之间的1变为0，0变为1；

四、3 a b —— 查询区间[a, b]里1的个数；

五、4 a b —— 查询区间[a, b]里最长的连续的1的个数；

分析：如果你会了区间覆盖 + 异或 + 合并，但是考虑不够细致的话，这道题可能无法1A。。。

对于这道题，我们大都可能采用两种标记，这里用我代码里面的变量——mark区间异或标记，cover区间覆盖标记。

具体区间覆盖 + 异或 + 合并操作，我就不多说了。

在PushDown函数里面，我们都是根据mark与cover的值来判断是否需要对子区间进行操作，但是这里要注意了！异或和覆盖的先后操作，在对子区间处理时需要不同的操作。

方案一：对区间我们先进行覆盖标记，再进行异或标记，其中change()是对节点信息进行修改的函数。

代码如下

void PushDown(int o)
{
    if(tree[o].cover != -1)
    {
        change(ll, tree[o].cover);
        change(rr, tree[o].cover);
        tree[o].cover = -1;
    }
    if(tree[o].mark)
    {
        change(ll, 2);
        change(rr, 2);
        tree[o].mark = 0;
    }
}

这里有二种可能

1，区间只有一种标记，这时无论怎么进行都不会影响信息的修改；

2，区间有两种标记（一种是以前未下传的标记，一种是新增的标记，属于两个不同的标记）

(1) 区间剩下的标记是覆盖标记，增加的是异或标记，那么按我们既定的顺序操作 ——>正确

(2) 区间剩下的标记是异或标记，增加的是覆盖标记，那么我们处理过覆盖标记后，以前的异或标记需要清除。

代码：

void change(int o, int v)//对节点o的信息进行修改
{
    if(v == 0 || v == 1)//覆盖处理
    {
        tree[o].l1 = tree[o].r1 = tree[o].s1 = v ? tree[o].len : 0;
        tree[o].l0 = tree[o].r0 = tree[o].s0 = v ? 0 : tree[o].len;
        tree[o].sum = v ? tree[o].len : 0;
        tree[o].cover = v;
        tree[o].mark = 0;//覆盖后 去掉异或操作
    }
    else//异或处理
    {
        swap(tree[o].l1, tree[o].l0);
        swap(tree[o].r1, tree[o].r0);
        swap(tree[o].s1, tree[o].s0);
        tree[o].sum = tree[o].len - tree[o].sum;
        tree[o].mark ^= 1;
    }
}

方案二：对区间先进行异或标记，再进行覆盖标记，我提供的代码用的是方案二，不再提供核心代码。

这里有二种可能

1，区间只有一种标记，这时无论怎么进行都不会影响信息的修改；

2，区间有两种标记（一种是以前未下传的标记，一种是新增的标记，属于两个不同的标记）

(1) 区间剩下的标记是异或标记，新增的是覆盖标记，那么按我们既定的顺序操作 ——>正确

(2) 区间剩下的标记是覆盖标记，新增的是异或标记，那么我们处理过异或标记后，以前的覆盖标记需要反转。

反转的意思是以前清0现在清1，以前清1现在清0。

AC代码：两种方案均已AC

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100000+10
#define lson o<<1, l, mid
#define rson o<<1|1, mid+1, r
#define ll o<<1
#define rr o<<1|1
using namespace std;
struct Tree
{
    int l, r, len;
    int l1, r1, s1;
    int l0, r0, s0;
    int sum;//区间里面1的个数
    int mark;//区间是否异或
    int cover;//区间是否覆盖
};
Tree tree[MAXN<<2];
void PushUp(int o)
{
    tree[o].l1 = tree[ll].l1;
    tree[o].r1 = tree[rr].r1;
    if(tree[o].l1 == tree[ll].len)
        tree[o].l1 += tree[rr].l1;
    if(tree[o].r1 == tree[rr].len)
        tree[o].r1 += tree[ll].r1;
    tree[o].s1 = max(max(tree[ll].s1, tree[rr].s1), tree[ll].r1 + tree[rr].l1);

    tree[o].l0 = tree[ll].l0;
    tree[o].r0 = tree[rr].r0;
    if(tree[o].l0 == tree[ll].len)
        tree[o].l0 += tree[rr].l0;
    if(tree[o].r0 == tree[rr].len)
        tree[o].r0 += tree[ll].r0;
    tree[o].s0 = max(max(tree[ll].s0, tree[rr].s0), tree[ll].r0 + tree[rr].l0);

    tree[o].sum = tree[ll].sum + tree[rr].sum;
}
void change(int o, int v)//对节点o的信息进行修改
{
    if(v == 0 || v == 1)//覆盖处理
    {
        tree[o].l1 = tree[o].r1 = tree[o].s1 = v ? tree[o].len : 0;
        tree[o].l0 = tree[o].r0 = tree[o].s0 = v ? 0 : tree[o].len;
        tree[o].sum = v ? tree[o].len : 0;
        tree[o].cover = v;
        //tree[o].mark = 0;//覆盖后 去掉异或操作
    }
    else//异或处理
    {
        swap(tree[o].l1, tree[o].l0);
        swap(tree[o].r1, tree[o].r0);
        swap(tree[o].s1, tree[o].s0);
        tree[o].sum = tree[o].len - tree[o].sum;
        tree[o].mark ^= 1;
        if(tree[o].cover != -1)//异或后 反转以前的覆盖
            tree[o].cover = 1 - tree[o].cover;
    }
}
void PushDown(int o)
{
//    if(tree[o].cover != -1)
//    {
//        change(ll, tree[o].cover);
//        change(rr, tree[o].cover);
//        tree[o].cover = -1;
//    }
    if(tree[o].mark)
    {
        change(ll, 2);
        change(rr, 2);
        tree[o].mark = 0;
    }
    if(tree[o].cover != -1)
    {
        change(ll, tree[o].cover);
        change(rr, tree[o].cover);
        tree[o].cover = -1;
    }
}
void build(int o, int l, int r)
{
    tree[o].l = l, tree[o].r = r;
    tree[o].len = r - l + 1;
    tree[o].mark = 0; tree[o].cover = -1;
    if(l == r)
    {
        int x;
        scanf("%d", &x);
        tree[o].l1 = tree[o].r1 = tree[o].s1 = x ? 1 : 0;
        tree[o].l0 = tree[o].r0 = tree[o].s0 = x ? 0 : 1;
        tree[o].sum = x ? 1 : 0;
        return ;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(o);
}
void update(int o, int L, int R, int kind)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        change(o, kind);//更改节点信息
        return ;
    }
    PushDown(o);
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        update(ll, L, R, kind);
    else if(L > mid)
        update(rr, L, R, kind);
    else
    {
        update(ll, L, mid, kind);
        update(rr, mid+1, R, kind);
    }
    PushUp(o);
}
int query(int o, int L, int R, int kind)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        if(kind == 3)
            return tree[o].sum;
        else
            return tree[o].s1;
    }
    PushDown(o);
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        return query(ll, L, R, kind);
    else if(L > mid)
        return query(rr, L, R, kind);
    else
    {
        int ans1 = query(ll, L, mid, kind);
        int ans2 = query(rr, mid+1, R, kind);
        if(kind == 3)
            return ans1 + ans2;
        else
            return max(max(ans1, ans2), min(mid-L+1, tree[ll].r1) + min(R-mid, tree[rr].l1));
    }
}
int main()
{
    int t;
    int n, q;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &q);
        build(1, 1, n);
        int op, x, y;
        while(q--)
        {
            scanf("%d%d%d", &op, &x, &y);
            x++, y++;
            if(op <= 2)
                update(1, x, y, op);
            else if(op >= 3)
                printf("%d\n", query(1, x, y, op));
        }
    }
    return 0;
}

笑着走完自己的路

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
hdoj 3397 Sequence operation 【线段树区间覆盖 + 异或 + 合并】【维护延迟标记的顺序】

Sequence operationTime Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 7238 Accepted Submission(s): 2165Problem Descriptionlxhgww
复制链接

扫一扫