Crayon 线段树或者树状数组

Crayon

Time Limit: 2000/1000MS (Java/Others) Memory Limit: 128000/64000KB (Java/Others)

SubmitStatus

Problem Description

Background

Mary love painting so much, but as we know she can't draw very well. There is no one appreciate her works, so she come up with a puzzle with herself.

Description

There are only one case in each input file, the first line is a integer N (N ≤ 1,000,00) denoted the total operations executed by Mary.

Then following N lines, each line is one of the folling operations.

• D L R : draw a segment [L, R], 1 ≤ L ≤  R ≤ 1,000,000,000.
• C I : clear the ith added segment. It’s guaranteed that the every added segment will be cleared only once.
• Q L R : query the number of segment sharing at least a common point with interval [L, R]. 1 ≤ L ≤ R ≤ 1,000,000,000.

Input

n

Then following n operations ...

Output

For each query, print the result on a single line ...

Sample Input

6
D 1 3
D 2 4
Q 2 3
D 2 4
C 2
Q 2 3

Sample Output

2
2

线段树

 #include <iostream>
 #include <stdio.h>
 #include <math.h>
 #include <string.h>
 #include <algorithm>
 using namespace std;
 #define ll long long
 typedef struct abcd
 {
     int l,r,ci,i;
     char x;
 } abcd;
 abcd a[];
 typedef struct abc
 {
     int x,i;
 } abc;
 abc c[];
 int cn=,b[],bn=;
 bool cmp(abc x,abc y)
 {
     return x.x<y.x;
 }
 bool cmp1(abcd x,abcd y)
 {
     return x.l<y.l;
 }
 bool cmp2(abcd x,abcd y)
 {
     return x.r<y.r;
 }
 bool cmp3(abcd x,abcd y)
 {
     return x.i<y.i;
 }
 typedef struct tree
 {
     int a,d,sub;
 } tree;
 tree t[];
 void fun(int x)
 {
     if(t[x].d)
     {
         t[x<<].d+=t[x].d;
         t[x<<].sub+=t[x].d;
         t[x<<|].sub+=t[x].d;
         t[x<<|].d+=t[x].d;
         t[x<<].a+=t[x].d;
         t[x<<|].a+=t[x].d;
         t[x].d=;
     }
 }
 void update(int x,int y,int b,int c,int tt,int z)
 {
     if(x<=b&&y>=c)
     {
         t[tt].sub+=z;
         t[tt].d+=z;
         t[tt].a+=z;
         return ;
     }
     if(t[tt].d)
     fun(tt);
     int m=(b+c)>>;
     if(x<=m&&y>m)t[tt].sub+=z;
     if(x<=m)update(x,y,b,m,tt<<,z);
     if(y>m)update(x,y,m+,c,tt<<|,z);
     t[tt].a=t[tt<<].a+t[tt<<|].a-t[tt].sub;
 }
 int query(int x,int y,int b,int c,int tt)
 {
     if(x<=b&&y>=c)
     {
         return t[tt].a;
     }
     if(t[tt].d)
     fun(tt);
     int m=(b+c)>>;
     int r=,sub;
     if(x<=m)r=query(x,y,b,m,tt<<);
     if(y>m)r=r+query(x,y,m+,c,tt<<|);
     t[tt].a=t[tt<<].a+t[tt<<|].a-t[tt].sub;
     if(x<=m&&y>m)
         return r-t[tt].sub;
     else return r;
 }
 int main()
 {
     int n,i,j;
    //freopen("in.txt","r",stdin);
     scanf("%d",&n);
     for(i=; i<n; i++)
     {
         getchar();
         scanf("%c",&a[i].x);
         if(a[i].x=='C')
         {
             scanf("%d",&a[i].ci);
         }
         else
         {
             scanf("%d%d",&a[i].l,&a[i].r);
             c[cn++].x=a[i].l,c[cn++].x=a[i].r;
             if(a[i].x=='D')
                 b[bn++]=i;
         }
         a[i].i=i;
     }
     int now=;
     sort(c,c+cn,cmp);
     c[].i=;
     for(i=; i<cn; i++)
     {
         if(c[i].x==c[i-].x)
             c[i].i=c[i-].i;
         else c[i].i=now++;
     }

     sort(a,a+n,cmp1);
     j=;
     for(i=; i<n; i++)
     {
         while(i<n&&a[i].x=='C')i++;
         if(i==n)break;
         while(a[i].l!=c[j].x)j++;
         a[i].l=c[j].i;
     }
     sort(a,a+n,cmp2);
     j=;
     for(i=; i<n; i++)
     {
         while(i<n&&a[i].x=='C')i++;
         if(i==n)break;
         while(a[i].r!=c[j].x)j++;
         a[i].r=c[j].i;
     }
     sort(a,a+n,cmp3);
     /*for(i=0; i<n; i++)
         cout<<a[i].x<<" "<<a[i].l<<" "<<a[i].r<<endl;*/
     memset(t,,sizeof(t));
     for(i=; i<n; i++)
     {
         if(a[i].x=='D')
         {
             update(a[i].l,a[i].r,,c[cn-].i,,);
         }
         else if(a[i].x=='C')
         {
             update(a[b[a[i].ci]].l,a[b[a[i].ci]].r,,c[cn-].i,,-);
         }
         else
         {
             printf("%d\n",query(a[i].l,a[i].r,,c[cn-].i,));
         }
     }
 }

树状数组

 #include <iostream>
 #include <stdio.h>
 #include <math.h>
 #include <string.h>
 #include <algorithm>
 using namespace std;
 #define ll long long
 typedef struct abcd
 {
     int l,r,ci,i;
     char x;
 } abcd;
 abcd a[];
 typedef struct abc
 {
     int x,i;
 } abc;
 abc c[];
 int cn=,b[],bn=;
 bool cmp(abc x,abc y)
 {
     return x.x<y.x;
 }
 bool cmp1(abcd x,abcd y)
 {
     return x.l<y.l;
 }
 bool cmp2(abcd x,abcd y)
 {
     return x.r<y.r;
 }
 bool cmp3(abcd x,abcd y)
 {
     return x.i<y.i;
 }
 int ab[][],m;
 int lowbit(int x)
 {
     return x&(-x);
 }
 void update(int y,int x,int z)
 {
     while(x<=m)
     {
         ab[x][y]+=z;
         x+=lowbit(x);
     }
 }
 int query(int y,int x)
 {
     int sum=;
     while(x>)
     {
         sum+=ab[x][y];
         x-=lowbit(x);
     }
     return sum;
 }
 int main()
 {
     int n,i,j;
    // freopen("in.txt","r",stdin);
     scanf("%d",&n);
     for(i=; i<n; i++)
     {
         getchar();
         scanf("%c",&a[i].x);
         if(a[i].x=='C')
         {
             scanf("%d",&a[i].ci);
         }
         else
         {
             scanf("%d%d",&a[i].l,&a[i].r);
             c[cn++].x=a[i].l,c[cn++].x=a[i].r;
             if(a[i].x=='D')
                 b[bn++]=i;
         }
         a[i].i=i;
     }
     int now=,sum=;
     sort(c,c+cn,cmp);
     c[].i=;
     for(i=; i<cn; i++)
     {
         if(c[i].x==c[i-].x)
             c[i].i=c[i-].i;
         else c[i].i=now++;
     }

     sort(a,a+n,cmp1);
     j=;
     for(i=; i<n; i++)
     {
         while(i<n&&a[i].x=='C')i++;
         if(i==n)break;
         while(a[i].l!=c[j].x)j++;
         a[i].l=c[j].i;
     }
     sort(a,a+n,cmp2);
     j=;
     for(i=; i<n; i++)
     {
         while(i<n&&a[i].x=='C')i++;
         if(i==n)break;
         while(a[i].r!=c[j].x)j++;
         a[i].r=c[j].i;
     }
     sort(a,a+n,cmp3);
     /*for(i=0; i<n; i++)
         cout<<a[i].x<<" "<<a[i].l<<" "<<a[i].r<<endl;*/
     m=c[cn-].i;
     for(i=; i<n; i++)
     {
         if(a[i].x=='D')
         {
             update(,a[i].l,);
             update(,a[i].r,);
             sum++;
         }
         else if(a[i].x=='C')
         {
             update(,a[b[a[i].ci]].l,-);
             update(,a[b[a[i].ci]].r,-);
             sum--;
         }
         else
         {
             int ans=query(,a[i].r);
             ans-=query(,a[i].l-);
             printf("%d\n",ans);
         }
     }
 }