codeforces 341d (树状数组)

problem Iahub and Xors

题目大意

　　一个n*n的矩阵，要求支持两种操作。

　　操作1：将一个子矩阵的所有值异或某个数。

　　操作2：询问某个子矩阵的所以值的异或和。

解题分析

　　由于异或的特殊性，可以用二维树状数组来维护。

　　因为同一个值只有异或奇数次才有效，因此若单点修改某个点，那么其影响的点为与其行和列奇偶性相同的点，故可以开4个二维树状数组来维护。

　　如果是区间修改x1,y1,x2,y2,则只需单点修改(x1,y1)、(x1,y2+1)、(x2+1,y2)、(x2+1,y2+1)

　　如果是区间询问x1,y1,x2,y2，则答案为(x2,y2)^(x1-1,y1-1)^(x1-1,y2)^(x2,y1-1)

参考程序

二维树状数组

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <string>
 #include <vector>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cassert>
 #include <iostream>
 #include <algorithm>
 #pragma comment(linker,"/STACK:102400000,102400000")
 using namespace std;

 #define N 1008
 #define M 50008
 #define LL long long
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 #define clr(x,v) memset(x,v,sizeof(x));
 #define bitcnt(x) __builtin_popcount(x)
 #define rep(x,y,z) for (int x=y;x<=z;x++)
 #define repd(x,y,z) for (int x=y;x>=z;x--)
 const int mo  = ;
 const int inf = 0x3f3f3f3f;
 const int INF = ;
 /**************************************************************************/ 

 struct Binary_Indexd_Tree{
     LL a[][][N][N];
     int n;
     void init(int x)
     {
         n=x;
         clr(a,);
     }
     void update(int x,int y,LL val)
     {
         for (int i=x;i<=n+;i+=i & (-i))
             for (int j=y;j<=n+;j+=j & (-j))
                 a[x & ][y & ][i][j]^=val;
     }
     LL query(int x,int y)
     {
         LL res=;
         for (int i=x;i;i-=i & (-i))
             for (int j=y;j;j-=j & (-j))
                 res^=a[x & ][y & ][i][j];
         return res;
     }
 }T;

 int main()
 {
     int n,q;
     scanf("%d",&n);
     T.init(n);
     scanf("%d",&q);
     rep(i,,q)
     {
         int op,x1,y1,x2,y2;
         LL val;
         scanf("%d%d%d%d%d",&op,&x1,&y1,&x2,&y2);
         if (op==)
         {
             scanf("%I64d",&val);
             T.update(x1,y1,val);
             T.update(x1,y2+,val);
             T.update(x2+,y1,val);
             T.update(x2+,y2+,val);
         }
         else
         {
             LL res=T.query(x2,y2);
             res^=T.query(x1-,y1-);
             res^=T.query(x1-,y2);
             res^=T.query(x2,y1-);
             printf("%I64d\n",res);
         }
     }
 }

四分树 T了= =

 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <string>
 #include <vector>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cassert>
 #include <iostream>
 #include <algorithm>
 #pragma comment(linker,"/STACK:102400000,102400000")
 using namespace std;

 #define N 3008
 #define M 50008
 #define LL long long
 #define son(x) rt*4+x-3
 #define clr(x,v) memset(x,v,sizeof(x));
 #define bitcnt(x) __builtin_popcount(x)
 #define rep(x,y,z) for (int x=y;x<=z;x++)
 #define repd(x,y,z) for (int x=y;x>=z;x--)
 const int mo  = ;
 const int inf = 0x3f3f3f3f;
 const int INF = ;
 /**************************************************************************/ 

 LL tag[N*N],lazy[N*N];
 struct interval{
     int l,r;
     interval(int l=,int r=):l(l),r(r){}
     int mid(){
         return l+r>>;
     }
     int len(){
         return r-l+;
     }
     interval left(){
         return interval(l,mid());
     }
     interval right(){
         return interval(mid()+,r);
     }
     bool intersect(interval x)
     {
         return !(x.r<l || x.l>r);
     }
     bool contain(interval x)
     {
         return l<=x.l && x.r<=r;
     }
     bool pt()
     {
         printf("%d %d ",l,r);
     }
 };
 void pushup(int rt)
 {
     tag[rt]=tag[son()]^tag[son()]^tag[son()]^tag[son()];
 }
 void pushdown(int rt,interval x,interval y)
 {
     if (lazy[rt])
     {
         lazy[son()]^=lazy[rt];
         lazy[son()]^=lazy[rt];
         lazy[son()]^=lazy[rt];
         lazy[son()]^=lazy[rt];
         if (x.left().len() * y.left().len() & ) tag[son()]^=lazy[rt];
         if (x.left().len() * y.right().len() & ) tag[son()]^=lazy[rt];
         if (x.right().len() * y.left().len() & ) tag[son()]^=lazy[rt];
         if (x.right().len() * y.right().len() & ) tag[son()]^=lazy[rt];
         lazy[rt]=;
     }
 }
 void build(interval x,interval y,int rt)
 {
     tag[rt]=; lazy[rt]=;
     if (x.len()<= || y.len()<=) return;
     if (x.len()== && y.len()==)
     {
         return;
     }
     build(x.left(),y.left(),son());
     build(x.left(),y.right(),son());
     build(x.right(),y.left(),son());
     build(x.right(),y.right(),son());
     pushup(rt);
 }
 LL query(interval X,interval Y,interval x,interval y,int rt)
 {
     if (x.len()<= || y.len()<=) return ;
     if (!x.intersect(X) || !y.intersect(Y)) return ;
     if (X.contain(x) && Y.contain(y))
     {
         return tag[rt];
     }
     pushdown(rt,x,y);
     LL res=;
     res^=query(X,Y,x.left(),y.left(),son());
     res^=query(X,Y,x.left(),y.right(),son());
     res^=query(X,Y,x.right(),y.left(),son());
     res^=query(X,Y,x.right(),y.right(),son());
     //x.pt(); y.pt(); printf("%lld\n",res);
     return res;
 }
 void update(interval X,interval Y,LL val,interval x,interval y,int rt)
 {
     if (x.len()<= || y.len()<=) return;
     if (!X.intersect(x) || !Y.intersect(y)) return;
     if (X.contain(x) && Y.contain(y))
     {
         if (x.len()*y.len() & ) tag[rt]^=val;
         lazy[rt]^=val;
         return;
     }
     pushdown(rt,x,y);
     update(X,Y,val,x.left(),y.left(),son());
     update(X,Y,val,x.left(),y.right(),son());
     update(X,Y,val,x.right(),y.left(),son());
     update(X,Y,val,x.right(),y.right(),son());
     pushup(rt);
 }
 int main()
 {
     int n,q;
     scanf("%d%d",&n,&q);
     build(interval(,n),interval(,n),);
     while (q--)
     {
         int x1,y1,x2,y2,op,val;
         scanf("%d%d%d%d%d",&op,&x1,&y1,&x2,&y2);
         if (op==)
         {
             scanf("%d",&val);
             update(interval(x1,x2),interval(y1,y2),val,interval(,n),interval(,n),);
         }
         else
         {
             cout << query(interval(x1,x2),interval(y1,y2),interval(,n),interval(,n),)<< endl;
         }
     }
 }