[BZOJ2120][BZOJ2453]-带修改莫队-时间复杂度理解

说在前面

第一次写带修改莫队，和普通莫队其实是差不多的，只不过细节多点
改天去把 回滚莫队 和 树上莫队 也学了，mark!!!
UPD at 2018.1.10 成功消除了之前留下的mark，开心!!

---

题目

BZOJ2120传送门
BZOJ2453传送门
（对，这也是一道双倍经验hhh）

题目大意

给出一个数列，以及一些操作。操作有两种，第一种是单点修改，第二种是询问[L,R]中出现了多少个不同的数字。保证数列中数字均在[1,1e6]范围内。

输入输出格式

输入格式：
第一行两个整数N，M，表示数列长度和操作个数
接下来一行N个整数表示数字个数
再接下来M行，每行一个三元组[char x y]描述一个操作
char为Q时，询问[x,y]
char为R时，把x位置的数字修改为y

输出格式：
对于每个询问，输出一行一个整数表示答案

---

解法

看到discuss里面说可以用暴力水过，于是开始了一系列卡常，然而失败了= =

咳咳….还是说说正解
普通的莫队询问只需要符合两个条件，可以直接移动指针L和R来维护
而带修改的莫队由于有时间纬度的限制（先修改再询问），因此一个询问要满足三个条件L，R和T，其中T表示时间纬度。

把修改和询问分开排序，修改按照时间排序，询问按照< 左端点块，右端点块，时间 >排序
每个块大小为 N23 ，时间复杂度上限 N53

证明如下：

对于左指针：
每个询问最多移动 N23 次，一共有 N 次询问，上限 N53

对于右指针：
相同 L 块内的询问， R 的块是单增的，单次询问最多移动 N23 次，一共 N 次询问，最多移动 N∗N23 次。
每跨越一个 L 块的时候， R 指针可以随便移动，单次跨越最多移动 N 次，一共 N13 次跨越，最多移动 N13∗N 次
综上，上限移动次数 N53

对于时间轴指针：
相同 L 块，相同 R 块内， T 是单增的，最多移动 N 次。
由于 L 和 R 所在块每变化一次， T 就会移动 N 次，且 L , R 块的变动次数最多是 N13∗N13 次，所以T移动次数上限是 N53

证毕

然后就可以愉快的开始写啦=w=

---

下面是自带大常数的代码

有一个细节需要注意，在移动T指针的时候，只有在当前[L,R]内才去修改cnt数组以及答案。
第73行和第79行的if就是干这个的（me被这个坑了一个多小时=A=）
代码略长…勿怪=w=

#include 
#include 
#include 
#include 
using namespace std ;

int N , M , a[10005] , ans[10005] , otop , Qtop ;
int Bsiz , Btot , blo[10005] , st[300] , ed[300] ;

struct Options{
    int pos , aim , pre , tim ;
    Options(){} ;
    Options( int pos_ , int aim_ , int _pre , int tim_ ):
        pos(pos_) , aim(aim_) , pre(_pre) , tim(tim_){} ;
}o[10005] ;

struct Queries{
    int L , R , tim , id ;
    Queries(){} ;
    Queries( int L_ , int R_ , int tim_ , int id_ ):
        L(L_) , R(R_) , tim(tim_) , id(id_){} ;

    bool operator < ( const Queries &A ) const {
        if( blo[L] == blo[A.L] ){
            if( blo[R] == blo[A.R] ) return tim < A.tim ;
            return blo[R] < blo[A.R] ;
        }
        return blo[L] < blo[A.L] ;
    }
}Q[10005] ;

inline int read_(){
    int rt = 0 ;
    char ch = getchar() ;
    while( ch < '0' || ch > '9' ) ch = getchar() ;
    while( ch >='0' && ch <='9' ) rt = rt * 10 + ch - '0' , ch = getchar() ;
    return rt ;
}

void readIn(){
    scanf( "%d%d" , &N , &M ) ;
    for( int i = 1 ; i <= N ; i ++ )
        a[i] = read_() ;
    char opt[10] ;
    for( int i = 1 , x , y ; i <= M ; i ++ ){
        scanf( "%s" , opt ) ; x = read_() , y = read_() ; 
        if( opt[0] == 'Q' )
            Qtop ++ , Q[Qtop] = (Queries){ x , y , i , Qtop } ;
        else
            otop ++ , o[otop] = (Options){ x , y , a[x] , i } , a[x] = y ;
    }
    o[otop+1].tim = 0x3f3f3f3f ;
    for( int i = otop ; i >= 1 ; i -- )
        a[ o[i].pos ] = o[i].pre ;
}

void setBlo(){
    Bsiz = (int )pow( N , 2.0/3.0 ) ;
    Btot = N / Bsiz ;
    if( N % Bsiz ) Btot ++ ;
    for( int i = 1 ; i <= Btot ; i ++ ){
        st[i] = ed[i-1] + 1 ;
        ed[i] = min( st[i] + Bsiz - 1 , N ) ;
        for( int j = st[i] ; j <= ed[i] ; j ++ )
            blo[j] = i ;
    }
}

short cate , lf , rg , now ;
short cnt[1000005] ; 

inline void Modify( int pos , int aim ){
    if( lf <= pos && pos <= rg ){
        cnt[ a[pos] ] -- ;
        if( cnt[ a[pos] ] == 0 ) cate -- ;
    }
    a[pos] = aim ;
    if( lf <= pos && pos <= rg ){
        cnt[ a[pos] ] ++ ;
        if( cnt[ a[pos] ] == 1 ) cate ++ ;
    }
}

void solve(){
    sort( Q + 1 , Q + Qtop + 1 ) ;
    lf = 1 , rg = 0 , now = 1 ;
    for( int i = 1 ; i <= Qtop ; i ++ ){
        int L = Q[i].L , R = Q[i].R , tim = Q[i].tim ;
        while( o[now].tim < tim ){
            Modify( o[now].pos , o[now].aim ) ;
            ++now ;
        }
        while( o[now-1].tim > tim ){
            now -- ;
            Modify( o[now].pos , o[now].pre ) ;
        }

        while( lf > L ){
            lf -- , cnt[ a[lf] ] ++ ;
            if( cnt[ a[lf] ] == 1 ) cate ++ ;
        }
        while( rg < R ){
            rg ++ , cnt[ a[rg] ] ++ ;
            if( cnt[ a[rg] ] == 1 ) cate ++ ;
        }
        while( lf < L ){
            cnt[ a[lf] ] -- ;
            if( cnt[ a[lf] ] == 0 ) cate -- ;
            lf ++ ;
        }
        while( rg > R ){
            cnt[ a[rg] ] -- ;
            if( cnt[ a[rg] ] == 0 ) cate -- ;
            rg -- ;
        }
        ans[ Q[i].id ] = cate ;
    }
    for( int i = 1 ; i <= Qtop ; i ++ )
        printf( "%d\n" , ans[i] ) ;
}

int main(){
    readIn() ;
    setBlo() ;
    solve() ;
}