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): 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
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;
}