P1903 [国家集训队]数颜色 (带修改莫队)

题目描述

墨墨购买了一套N支彩色画笔（其中有些颜色可能相同），摆成一排，你需要回答墨墨的提问。墨墨会向你发布如下指令：

1、 Q L R代表询问你从第L支画笔到第R支画笔中共有几种不同颜色的画笔。

2、 R P Col 把第P支画笔替换为颜色Col。

为了满足墨墨的要求，你知道你需要干什么了吗？

输入输出格式

输入格式：

第1行两个整数N，M，分别代表初始画笔的数量以及墨墨会做的事情的个数。

第2行N个整数，分别代表初始画笔排中第i支画笔的颜色。

第3行到第2+M行，每行分别代表墨墨会做的一件事情，格式见题干部分。

输出格式：

对于每一个Query的询问，你需要在对应的行中给出一个数字，代表第L支画笔到第R支画笔中共有几种不同颜色的画笔。

输入输出样例

输入样例#1： 复制

6 5
1 2 3 4 5 5
Q 1 4
Q 2 6
R 1 2
Q 1 4
Q 2 6

输出样例#1： 复制

4
4
3
4

说明

对于100%的数据，N≤10000，M≤10000，修改操作不多于1000次，所有的输入数据中出现的所有整数均大于等于1且不超过10^6。

来源：bzoj2120

 //感谢xxy dalao的指导， 虽然不得不看了blog才A了这道题。。。。 

 //但是为什么他们一个 dfs 10+ ms就过，我却跑了100+ ？。。。。。 

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 using namespace std;

 const int N=1e4+;
 const int M=1e6+;

 int n,m;
 int a[N];
 int ans;
 int belong[N];
 int c[M];
 int query_cnt,modify_cnt;
 struct Query    //询问操作
 {
     int ans;    //这次询问的答案
     int l,r;    //这次询问的左右区间
     int tim;    //这是第几次询问，便于最后将询问排序输出ans
     int tim_modify;        //记录这次询问是在第几次修改之后的，便于修改和撤销
 }query[N];
 struct Modify    //修改操作
 {
     int tim;    //这是第几次修改操作
     int pos,col,pre_col;    //修改的位置、修改之前的颜色、修改之后的颜色
 }modify[N];

 int read()
 {
     char c=getchar();int num=;
     for(;!isdigit(c);c=getchar())
         if(c=='Q')
             return ;
         else if(c=='R')
             return ;
     for(;isdigit(c);c=getchar())
         num=num*+c-'';
     return num;
 }

 bool cmp1(const Query &a,const Query &b)    //将询问操作排序
 {
     if(belong[a.l]==belong[b.l])    //为了保证效率，按照三个关键字排序，前两个和普通的不带修改的莫队一样，第三个关键字是修改时间
         if(belong[a.r]==belong[b.r])
             return a.tim_modify<b.tim_modify;
         else
             return belong[a.r]<belong[b.r];
     return belong[a.l]<belong[b.l];
 }

 bool cmp2(const Query &a,const Query &b)    //将query按照询问时间排序，便于输出ans
 {
     return a.tim<b.tim;
 }

 int main()
 {
     n=read(),m=read();
     int size=sqrt(n);
     for(int i=;i<=n;++i)
         a[i]=read(),belong[i]=(i-)/size+;
     for(int i=,type;i<=m;++i)
     {
         type=read();
         if(type==)
         {
             ++query_cnt;
             query[query_cnt].l=read();
             query[query_cnt].r=read();
             query[query_cnt].tim=query_cnt;        //记录这是第几次询问
             query[query_cnt].tim_modify=modify_cnt;        //记录当前询问是在第几次修改之后
         }
         else
         {
             ++modify_cnt;
             modify[modify_cnt].pos=read();
             modify[modify_cnt].col=read();    //修改之后的值
             modify[modify_cnt].tim=modify_cnt;
             modify[modify_cnt].pre_col=a[modify[modify_cnt].pos];    //记录修改之前的值
             a[modify[modify_cnt].pos]=modify[modify_cnt].col;    //修改
         }
     }
     for(int i=modify_cnt;i;--i)        //把修改了的a数组还原回去
         a[modify[i].pos]=modify[i].pre_col;
     sort(query+,query+query_cnt+,cmp1);
     int now_modify=,l=,r=;
     for(int i=;i<=query_cnt;++i)        //当时被卡在了修改和撤销上，没理解透彻，不知道该不该更新ans，因为当时觉得如果更新了ans的话会让后边在移动左右端点更新值得时候重复，其实不然，因为如果当前修改的值在当前询问的区间中，那么它是不会被更改的（因为改到左右端点的时候就停止了，不会来改它），如果不在当前询问的区间内，那么在移动端点的时候，被+1的ans会被还原回去（-1），但是被-1的ans是不会变的，因为它已经没了（滑稽）
     {
         if(query[i].tim_modify>now_modify)    //当前询问在上次修改操作之后，往后修改
         {
             for(int j=now_modify+;j<=query[i].tim_modify;++j)
             {
                 if(modify[j].pos>=l&&modify[j].pos<=r)        //如果修改的位置在上次询问的区间内，更新
                 {
                     --c[modify[j].pre_col];
                     if(!c[modify[j].pre_col])
                         --ans;
                     if(!c[modify[j].col])
                         ++ans;
                     ++c[modify[j].col];
                 }
                 a[modify[j].pos]=modify[j].col;        //修改
             }
         }
         if(query[i].tim_modify<now_modify)        //当前询问在上次修改操作之前，撤销修改
         {
             for(int j=now_modify;j>query[i].tim_modify;--j)
             {
                 if(modify[j].pos>=l&&modify[j].pos<=r)
                 {
                     --c[modify[j].col];        //把修改后的数的值还原回去
                     if(!c[modify[j].col])
                         --ans;
                     if(!c[modify[j].pre_col])    //被修改了的数的值还原回去
                         ++ans;
                     ++c[modify[j].pre_col];
                 }
                 a[modify[j].pos]=modify[j].pre_col;        //撤销
             }
         }
         if(l<query[i].l)
         {
             for(int j=l;j<query[i].l;++j)
             {
                 --c[a[j]];
                 if(!c[a[j]])
                     --ans;
             }
         }
         if(l>query[i].l)
         {
             for(int j=query[i].l;j<l;++j)
             {
                 if(!c[a[j]])
                     ++ans;
                 ++c[a[j]];
             }
         }
         if(r<query[i].r)
         {
             for(int j=r+;j<=query[i].r;++j)
             {
                 if(!c[a[j]])
                     ++ans;
                 ++c[a[j]];
             }
         }
         if(r>query[i].r)
         {
             for(int j=query[i].r+;j<=r;++j)
             {
                 --c[a[j]];
                 if(!c[a[j]])
                     --ans;
             }
         }
         l=query[i].l,r=query[i].r;    //更新查询区间
         query[i].ans=ans;    //记录这次查询的答案
         now_modify=query[i].tim_modify;        //更新最新一次修改时间
     }
     sort(query+,query+query_cnt+,cmp2);
     for(int i=;i<=query_cnt;++i)
     {
         printf("%d\n",query[i].ans);
     }
     return ;
 }