hdu 3911 black and white 线段树区间合并

线段树题目的类型大致可以分为四种：单点更新、成段增减或更新、区间合并和扫描线

成段更新和区间合并都需要用到Lazy思想。

扫描线就是求矩形面积和周长的题目，需要用到离散化。

本篇讲解区间合并，区间合并肯定是从子节点向上才能用着合并，这类题目都是求最长连续区间的，主要在PushUp的时候需要对左右儿子的区间进行合并。

这里就直接拿题目说事，所有的解释全部在代码的注释里。

4

1 0 1 0

5

0 1 4

1 2 3

0 1 4

1 3 3

0 4 4

首先输入N，表示序列长度，接下来一行输入4个数，只有0和1；接着输入一个值m表示m个操作，每个操作输入三个数a,b,c，a只有0和1，0表示查询[b,c]区间最长的连续1的长度，1表示将区间[b,c]内的0,1翻转。

[html]  view plain  copy

 print ?

1. struct Node  
2. {  
3.     int l,r;  
4.     int lsum0,lsum1,rsum0,rsum1,msum0,msum1;//lsum0,rsum0,msum0分别表示一条线段从左边数最长连续的0个数，从右边最长连续0的个数，这条线段最长连续0的个数，同理lsum1,rsum1,msum1就不解释了  
5.     int ck;//=0时表示不用翻转，=1时才翻转  
6.     int mid()  
7.     {  
8.         return (l+r)>>1;  
9.     }  
10. } tree[N << 2];  
11.   
12. int a[N];  
13.   
14. void PushUp(int rt)//合并操作  
15. {  
16.     int ll = tree[rt<<1].r - tree[rt<<1].l + 1;//求左子树的线段长度  
17.     int rl = tree[rt<<1|1].r - tree[rt<<1|1].l + 1;//求右子树的线段长度  
18.   
19.     tree[rt].lsum1 = tree[rt<<1].lsum1;//首先求rt节点左边连续1个数，首先毋庸至于等于左子树的左边连续1的个数  
20.     if(tree[rt<<1].lsum1 == ll) tree[rt].lsum1 += tree[rt<<1|1].lsum1;//如果左子树连续1的个数刚好等于左子树的长度，那么rt节点的左边连续1的个数还需要加上右子树左边连续1的个数。下面的类似，这就是合并过程  
21.   
22.     tree[rt].rsum1 = tree[rt<<1|1].rsum1;  
23.     if(tree[rt<<1|1].rsum1 == rl) tree[rt].rsum1 += tree[rt<<1].rsum1;  
24. //介绍如何求根节点最长连续1的个数，它是左子树最长连续1个数、右子树最长连续1个数和（左子树右边连续1的个数+右子树左边连续1的个数）三者的最大值  
25.     tree[rt].msum1 = max((tree[rt<<1].rsum1 + tree[rt<<1|1].lsum1) , max(tree[rt<<1].msum1,tree[rt<<1|1].msum1));  
26.   
27.     tree[rt].lsum0 = tree[rt<<1].lsum0;  
28.     if(tree[rt<<1].lsum0 == ll) tree[rt].lsum0 += tree[rt<<1|1].lsum0;  
29.   
30.     tree[rt].rsum0 = tree[rt<<1|1].rsum0;  
31.     if(tree[rt<<1|1].rsum0 == rl) tree[rt].rsum0 += tree[rt<<1].rsum0;  
32.   
33.     tree[rt].msum0 = max( (tree[rt<<1].rsum0 + tree[rt<<1|1].lsum0) , max(tree[rt<<1].msum0,tree[rt<<1|1].msum0));  
34. }  
35.   
36.   
37. void PushDown(int rt)//从父节点向下更新，这里其实是Lazy  
38. {  
39.     if(tree[rt].ck == 1)//如果ck=1表示这里需要翻转，翻转其实就是把左右子树的0,1的lsum，rsum,msum交换  
40.     {  
41.         tree[rt<<1].ck ^= 1;//这里如果有疑问为什么是异或操作的话，因为现在左子树的父亲节点rt的线段所有0,1需要交换，那么他的左子树的线段是从父亲节点的线段继承下来的，当然也需要交换（下面的就是交换代码），那么左子树的左右子树也需要交换，如果原来tree[rt<<1].ck=1则说明原来左子树的左右子树就需要交换，现在还需要交换，交换两次等于没有交换，那么异或之后就不用交换了。所以刚好，需要用异或操作。  
42.         tree[rt<<1|1].ck ^= 1;  
43.         tree[rt].ck = 0;//恢复rt的ck值为0，它的左右子树已经交换了  
44.         swap(tree[rt<<1].lsum1,tree[rt<<1].lsum0);  
45.         swap(tree[rt<<1].rsum1,tree[rt<<1].rsum0);  
46.         swap(tree[rt<<1].msum1,tree[rt<<1].msum0);  
47.   
48.         swap(tree[rt<<1|1].lsum1,tree[rt<<1|1].lsum0);  
49.         swap(tree[rt<<1|1].rsum1,tree[rt<<1|1].rsum0);  
50.         swap(tree[rt<<1|1].msum1,tree[rt<<1|1].msum0);  
51.     }  
52. }  
53.   
54. void build(int l,int r,int rt)//建树  
55. {  
56.     tree[rt].l = l;  
57.     tree[rt].r = r;  
58.     tree[rt].ck = 0;//初始化都不需要交换  
59.     if(l == r)//到每个叶子节点，付给初始值，这里不用解释  
60.     {  
61.         if(a[l] == 1)//black  
62.         {  
63.             tree[rt].lsum1 = tree[rt].rsum1 = tree[rt].msum1 = 1;  
64.             tree[rt].lsum0 = tree[rt].rsum0 = tree[rt].msum0 = 0;  
65.         }  
66.         else  
67.         {  
68.             tree[rt].lsum1 = tree[rt].rsum1 = tree[rt].msum1 = 0;  
69.             tree[rt].lsum0 = tree[rt].rsum0 = tree[rt].msum0 = 1;  
70.         }  
71.         return;  
72.     }  
73.     int m = (l + r) >> 1;  
74.     build(l,m,rt<<1);  
75.     build(m+1,r,rt<<1|1);  
76.     PushUp(rt);//从叶子节点递归向上合并  
77. }  
78.   
79. void update(int l,int r,int rt)  
80. {  
81.     if(tree[rt].l == l && tree[rt].r == r)//刚好是需要更新区间[l,r]，直接更新  
82.     {  
83.         tree[rt].ck ^= 1;  
84.         swap(tree[rt].lsum1,tree[rt].lsum0);//更新rt节点线段的值  
85.         swap(tree[rt].rsum1,tree[rt].rsum0);  
86.         swap(tree[rt].msum1,tree[rt].msum0);  
87.         return;//这里直接return，根据Lazy的思想，只有在用到子树的时候才去更新子树  
88.     }  
89.     PushDown(rt);//这里需要用到子树的值，需要去更新  
90.     int m = tree[rt].mid();  
91.     if(r <= m) update(l,r,rt<<1);  
92.     else if(l > m) update(l,r,rt<<1|1);  
93.     else  
94.     {  
95.         update(l,m,rt<<1);  
96.         update(m+1,r,rt<<1|1);  
97.     }  
98.     PushUp(rt);//同样需要向上合并  
99. }  
100.   
101. int query(int l,int r,int rt)//查询  
102. {  
103.     if(tree[rt].l == l && tree[rt].r == r)//刚好到查询区间  
104.     {  
105.         return tree[rt].msum1;  
106.     }  
107.     PushDown(rt);//同样是Lazy  
108.     int m = tree[rt].mid();  
109.     if(r <= m)  return query(l,r,rt<<1);//在左子树  
110.     else if(l>m) return query(l,r,rt<<1|1);//在右子树  
111.     else  
112.     {//这种情况就需要判断，左子树、右子树和中间三者的最大值  
113.         int lr = query(l,m,rt<<1);//左子树  
114.         int rr = query(m+1,r,rt<<1|1);//右子树  
115.         //中间  
116.         int a = tree[rt<<1].rsum1;//左子树右边最长连续1，注意它的个数不应该大于区间[l,tree[rt<<1].r]的个数  
117.         if(a > tree[rt<<1].r - l + 1) a = tree[rt<<1].r-l+1;  
118.   
119.         int b = tree[rt<<1|1].lsum1;//右子树左边最长连续1，注意它的个数不应该大于区间[tree[rt<<1|1].l,r]的个数  
120.         if(b > r - tree[rt<<1|1].l + 1) b = r - tree[rt<<1|1].l + 1;  
121.         return max(max(lr,rr),a+b);//最后取左子树、右子树和中间三者的最大值  
122.     }  
123. }  
124.   
125. int main()  
126. {  
127.     int n,m,t,b,c;  
128.     while(scanf("%d",&n) != EOF)  
129.     {  
130.         for(int i = 1; i <= n ; i ++) scanf("%d",&a[i]);  
131.         build(1,n,1);  
132.         scanf("%d",&m);  
133.         while(m--)  
134.         {  
135.             scanf("%d %d %d",&t,&b,&c);  
136.             if(t==0)  
137.             {  
138.                 printf("%d\n",query(b,c,1));  
139.             }  
140.             else  
141.             {  
142.                 update(b,c,1);  
143.             }  
144.         }  
145.     }  
146.     return 0;  
147. }