spoj IITWPC4F - Gopu and the Grid Problem 线段树

IITWPC4F - Gopu and the Grid Problem

no tags 

Gopu is interested in the integer co-ordinates of the X-Y plane (0<=x,y<=100000). Each integer coordinate contain a lamp, initially all the lamps are in off mode. Flipping a lamp means switching it on if it is in off mode and vice versa. Maggu will ask gopu 3 type of queries.

Type 1:  x l r,  meaning: flip all the lamps whose x-coordinate are between l and r (both inclusive) irrespective of the y coordinate.

Type 2:  y l r, meaning: flip all the lamps whose y-coordinate are between l and r (both inclusive) irrespective of the x coordinate.

Type 3: q x y X Y, meaning: count the number of lamps which are in ‘on mode’(say this number be A) and ‘off mode’ (say this number  be B) in the region where x-coordinate is between x and X(both inclusive) and y-coordinate is between y and Y(both inclusive).

Input

First line contains Q-number of queries that maggu will ask to gopu. (Q <= 10^5)

Then there will be Q lines each containing a query of one of the three type described above.

Output

For each query of 3rd type you need to output a line containing one integer A.

Example

Input:

3

x 0 1

y 1 2

q 0 0 2 2

Output: 

 4

线段树

题目链接：http://www.spoj.com/problems/IITWPC4F/en/

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstring>
#include<vector>
#include<list>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define pi (4*atan(1.0))
#define mk make_pair
#define eps 1e-7
#define bug(x)  cout<<"bug"<<x<<endl;
const int N=5e5+,M=1e6+,inf=;
const ll INF=1e18+,mod=;

///   数组大小
struct SGT
{
    int tree[N],lazy[N];
    void pushup(int pos)
    {
        tree[pos]=tree[pos<<|]+tree[pos<<];
    }
    void pushdown(int pos,int l,int r)
    {
        if(lazy[pos])
        {
            lazy[pos<<]^=;
            lazy[pos<<|]^=;
            int mid=(l+r)>>;
            tree[pos<<]=(mid-l+)-tree[pos<<];
            tree[pos<<|]=(r-mid)-tree[pos<<|];
            lazy[pos]=;
        }
    }
    void build(int l,int r,int pos)
    {
        tree[pos]=lazy[pos]=;
        if(l==r)return;
        int mid=(l+r)>>;
        build(l,mid,pos<<);
        build(mid+,r,pos<<|);
    }
    void update(int L,int R,int l,int r,int pos)
    {
        if(L<=l&&r<=R)
        {
            lazy[pos]^=;
            tree[pos]=(r-l+)-tree[pos];
            return;
        }
        pushdown(pos,l,r);
        int mid=(l+r)>>;
        if(L<=mid)
            update(L,R,l,mid,pos<<);
        if(R>mid)
            update(L,R,mid+,r,pos<<|);
        pushup(pos);
    }
    int query(int L,int R,int l,int r,int pos)
    {
        if(L<=l&&r<=R)
            return tree[pos];
        pushdown(pos,l,r);
        int mid=(l+r)>>;
        int ans=;
        if(L<=mid)
            ans+=query(L,R,l,mid,pos<<);
        if(R>mid)
            ans+=query(L,R,mid+,r,pos<<|);
        return ans;
    }
};
SGT x,y;
char ch[];
int main()
{
    int q;
    int n=;
    while(~scanf("%d",&q))
    {
        x.build(,n,);
        y.build(,n,);
        while(q--)
        {
            int l,r;
            scanf("%s%d%d",ch,&l,&r);
            //if(l<r)swap(l,r);
            if(ch[]=='x')
                x.update(l+,r+,,n,);
            else if(ch[]=='y')
                y.update(l+,r+,,n,);
            else
            {
                int L,R;
                scanf("%d%d",&L,&R);
                //if(L<R)swap(L,R);
                int xx=x.query(l+,L+,,n,);
                int yy=y.query(r+,R+,,n,);
                ll ans=;
                ans+=1LL*xx*(R-r+);
                ans+=1LL*yy*(L-l+);
                ans-=2LL*xx*yy;
                printf("%lld\n",ans);
            }
        }
    }
    return ;
}