bzoj 1018 堵塞的交通

传送门：http://www.lydsy.com/JudgeOnline/showsource.php?id=1304322
这是一道好题，不容易想到线段树和维护的量。
分析题目，考虑联通方式，发现只有3种，我一开始的想法是结构分块，使用并查集维护，O(1)添加很自然，删除的话就暴力重建块内的并查集O(sqrt(n))，查询的时候仍然考虑并查集维护，求出关键点（上下左右4个）和他们之间的联通性，数量级是O(sqrt(n)）的，这一步复杂度自然也是O(nsqrt(n))的，然而这样还不够科学。
当然，另一种分块方式比较奇特（！！！），对询问分块，每次暴力重建并查集，删除的边看做不存在，这样重建sqrt(n)次，每次复杂度O(n），这一步复杂度O(nsqrt(n))，重建后对于每次操作添加询问块内改变的O(sqrt(n))条边，但每次完成后要消除影响，这一步比较麻烦可以用递归完成，回溯的时候修改并查集的对应值，单次查询O(sqrt(n)),这样总复杂度：O(nsqrt(n)),对询问分块然后暴力重建是常用的分块套路，然而这仍然不狗科学，我们看上去需要一个log级别的算法，考虑到行数较少只有2，我们选择用线段树维护连通性。
想到线段树，一切就很明显了，类似于DP，维护四个边界点的连通性6个量，这是可合并的，注意查询的时候3种方式，复杂度：O(nlog(n))

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#define N 100000
using namespace std;
struct node{ bool g[6]; };
int n;
node s[5],A[(N<<2)+5];
bool map[(N<<2)+5];
inline int calc(int x,int y){ return x*(n-1)+y;}
inline int getnum(){
    char c; int num;
    while (!isdigit(c = getchar()));
    num = c - '0';
    while (isdigit(c = getchar())) num = 10 *num + c -'0';
    return num;
}

void init(){
    n = getnum();
    s[0] = (node){1,1,0,0,0,0};
    s[1] = (node){1,1,1,1,1,1};
    memset(map,0,sizeof(map));
    memset(A,0,sizeof(A));
}

inline void build(int l,int r,int rt){
    int mid = (l+r)>>1;
    if (l==r) { A[rt] = s[0]; return;}
    build(l,mid,rt<<1);
    build(mid+1,r,rt<<1|1); 
}

inline node merge(node a,node b,bool x,bool y){
    node c;
    c.g[0] = (a.g[0]&&x&&b.g[0])||(a.g[4]&&y&&b.g[5]);
    c.g[1] = (a.g[1]&&y&&b.g[1])||(a.g[5]&&x&&b.g[4]);
    c.g[2] = (a.g[2])||(a.g[0]&&x&&b.g[2]&&y&&a.g[1]);
    c.g[3] = (b.g[3])||(b.g[0]&&x&&a.g[3]&&y&&b.g[1]);
    c.g[4] = (a.g[0]&&x&&b.g[4])||(a.g[4]&&y&&b.g[1]);
    c.g[5] = (b.g[0]&&x&&a.g[5])||(b.g[5]&&y&&a.g[1]);
    return c;
}

inline void insert(int l,int r,int rt,int x1,int y1,int x2,int y2,bool c){
    int mid = (l+r)>>1,y = min(y1,y2);
    if (x1==x2&&y==mid) {  map[calc(x1,y)] = c; A[rt] = merge(A[rt<<1],A[rt<<1|1],map[calc(0,mid)],map[calc(1,mid)]); return;}
    else if (x1!=x2&&l==r) { map[2*(n-1)+y] = c; A[rt] = s[c]; return;}
    if (y<=mid) insert(l,mid,rt<<1,x1,y1,x2,y2,c);
    if (y>mid) insert(mid+1,r,rt<<1|1,x1,y1,x2,y2,c);
    A[rt] = merge(A[rt<<1],A[rt<<1|1],map[calc(0,mid)],map[calc(1,mid)]);
}

inline node query(int l,int r,int rt,int ll,int rr){
     int mid = (r+l)>>1;
     if (l>=ll&&r<=rr) return A[rt];
     if (rr<=mid) return query(l,mid,rt<<1,ll,rr);
     if (ll>mid) return query(mid+1,r,rt<<1|1,ll,rr);
     else return merge(query(l,mid,rt<<1,ll,rr),query(mid+1,r,rt<<1|1,ll,rr),map[calc(0,mid)],map[calc(1,mid)]);
}

inline void ask(int x1,int y1,int x2,int y2){
    bool ans;
    if (y1>y2) swap(x1,x2),swap(y1,y2);
    s[2] = query(1,n,1,y1,y2);
    //for (int i = 0;i < 6; ++i) cout<<s[2].g[i]<<" ";
    //cout<<endl;
    s[3] = query(1,n,1,1,y1);
    //for (int i = 0;i < 6; ++i) cout<<s[3].g[i]<<" ";
    //cout<<endl;
    s[4] = query(1,n,1,y2,n);
    //for (int i = 0;i < 6; ++i) cout<<s[4].g[i]<<" ";
    cout<<endl;
    if (x1==x2) 
      ans = (s[2].g[x1])||(s[3].g[3]&&s[2].g[4+x1^1])||(s[4].g[2]&&s[2].g[4+x1])||(s[3].g[3]&&s[4].g[2]&&s[2].g[x1^1]); 
    if (x1!=x2) 
      ans = (s[2].g[4+x1])||(s[3].g[3]&&s[2].g[x1^1])||(s[4].g[2]&&s[2].g[x1])||(s[3].g[3]&&s[4].g[2]&&s[2].g[4+x1^1]);
    if (ans) puts("Y");
    else puts("N"); 
}

void DO_IT(){
    char ch[6];
    int x1,y1,x2,y2;
    scanf("%s",ch);
    while (ch[0]!='E'){
        x1 = getnum()-1; y1 = getnum(); x2 = getnum()-1; y2 = getnum(); 
        if (ch[0] == 'O') insert(1,n,1,x1,y1,x2,y2,1);
        if (ch[0] == 'C') insert(1,n,1,x1,y1,x2,y2,0);
        if (ch[0] == 'A') ask(x1,y1,x2,y2);
        scanf("%s",ch);
    }
}

int main(){
    //freopen("a.in","r",stdin);
    //freopen("a.out","w",stdout); 
    init();
    build(1,n,1);
    DO_IT();
    //fclose(stdin); fclose(stdout);
    return 0;
}

分块代码（！！！）：

总结：1.注意用位运算减少分情况讨论数量，减少代码量
2.写较繁琐的程序之前一定想好每个细节然后再写
3.尝试一题多解并code，不要偷懒

sb问题：如果将修改和删除改为一整行呢？