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+5;
const int M=1e6+5;

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=0;
    for(;!isdigit(c);c=getchar())
        if(c=='Q')
            return 1;
        else if(c=='R')
            return 2;
    for(;isdigit(c);c=getchar())
        num=num*10+c-'0';
    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=1;i<=n;++i)
        a[i]=read(),belong[i]=(i-1)/size+1;
    for(int i=1,type;i<=m;++i)
    {
        type=read();
        if(type==1)
        {
            ++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+1,query+query_cnt+1,cmp1);
    int now_modify=0,l=1,r=0;
    for(int i=1;i<=query_cnt;++i)        //当时被卡在了修改和撤销上，没理解透彻，不知道该不该更新ans，因为当时觉得如果更新了ans的话会让后边在移动左右端点更新值得时候重复，其实不然，因为如果当前修改的值在当前询问的区间中，那么它是不会被更改的（因为改到左右端点的时候就停止了，不会来改它），如果不在当前询问的区间内，那么在移动端点的时候，被+1的ans会被还原回去（-1），但是被-1的ans是不会变的，因为它已经没了（滑稽） 
    {
        if(query[i].tim_modify>now_modify)    //当前询问在上次修改操作之后，往后修改 
        {
            for(int j=now_modify+1;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+1;j<=query[i].r;++j)
            {
                if(!c[a[j]])
                    ++ans;
                ++c[a[j]];
            }
        }
        if(r>query[i].r)
        {
            for(int j=query[i].r+1;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+1,query+query_cnt+1,cmp2);
    for(int i=1;i<=query_cnt;++i)
    {
        printf("%d
",query[i].ans);
    }
    return 0;
}