【莫队】莫队算法的扩展

一）树上莫队

普通的莫队非常容易掌握。那么我们可以把它扩展到树上。
简单地来说，树上莫队是利用了dfs序的莫队。为了保证复杂度的稳定性，两个块之间的元素个数差不应超出三倍。仍然分√n个块，每块√n个元素。dfs过程中记录一个栈内有多少元素，大于等于√n个时分一块。dfs完剩下的分到最后一个块，这样就能保证复杂度在O(n√n)了。

例题：BZOJ1086

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#define ll long long
#define inf 0x7f7f7f7f
#define N 2005
using namespace std;
struct edge
{
    int v,nex;
    edge(){}
    edge(int a,int b):v(a),nex(b){}
}e[N];
int tot,hd[N];
void add(int x,int y)
{
    e[++tot]=edge(y,hd[x]);hd[x]=tot;
    e[++tot]=edge(x,hd[y]);hd[y]=tot;
}
int n,b,x,y,top,st[N],sd[N],cnt,bl[N];
void dfs(int u,int fa)
{
    int now=top;
    for(int i=hd[u];i;i=e[i].nex)
    {
        int v=e[i].v;
        if(v==fa) continue;
        dfs(v,u);
        if(top-now>=b)
        {
            sd[++cnt]=u;
            while(top!=now) bl[st[top--]]=cnt;
        }
    }
    st[++top]=u;
}
int main()
{
    scanf("%d%d",&n,&b);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    dfs(1,0);
    while(top) bl[st[top--]]=cnt;
    printf("%d\n",cnt);
    for(int i=1;i<n;i++) printf("%d ",bl[i]);
    printf("%d\n",bl[n]);
    for(int i=1;i<cnt;i++) printf("%d ",sd[i]);
    printf("%d\n",sd[cnt]);
    return 0;
}

二）带修莫队

带修莫队，即带修改的莫队。假设是一个序列的带修莫队（否则用上述方法转化）。假设把序列分成m块，然后以l所在块为第一关键字，以r所在块为第二关键字，以时间t为第三关键字排序，那么现在考虑转移的情况：
1.同一组（l所在块相同且r所在块也相同的操作为一组）中t的转移，由于同一块中t是升序排列的，因此每一组中t的转移是O(N)的。组数为m^2，因此总时间O(Nm^2)；
2.同一组中l和r的转移。在同一组中l和r的范围都不超过N/m，因此每一次转移都是O(N/m)的。总共有N次转移，因此是O(N^2/m)；
3.一组转移到另一组。每次最多O(N)，而组数只有m^2，因此最多转移O(m^2)次，总时间复杂度O(Nm^2)。
把三个合起来，可以看到带修莫队的时间复杂度为O(N(N/m+m^2))，当m=N^(1/3)时，有最小的时间复杂度O(N^(5/3))，这也是带修莫队的时间复杂度。不得不说是个玄学的复杂度。假如有四个元素那岂不是什么O(N^(7/4))了哈哈哈哈

例题：BZOJ2453&2120（2120Po神有暴力做法，%%%）

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#define ll long long
#define inf 0x7f7f7f7f
#define N 100005
using namespace std;
ll read()
{
    ll x=0,f=1;
    char c=getchar();
    while(c<'0' || c>'9') {if(c=='-') f=-1;c=getchar();}
    while(c<='9' && c>='0') {x=x*10+c-'0';c=getchar();}
    return x*f;
}
int a[N],tmp[N],bl[N],ans[N];
int n,m,blo,cnt,cnt2,x,y;
char ch[5];
int l=1,r=0,cur=0,now,c[1000005];
struct que
{
    int id,l,r,tim;
    que(){}
    que(int a,int b,int c,int d):id(d),l(a),r(b),tim(c){} 
    bool operator < (const que& b) const
    {
        if(bl[l]==bl[b.l])
        {
            if(bl[r]==bl[b.r]) return tim<b.tim;
            return r<b.r;
        }
        return l<b.l;
    }
}q[N];
struct work
{
    int p,v,las;
    work(){}
    work(int a,int b,int c):p(a),v(b),las(c){}
}w[N];
void add(int x)
{
    c[x]++;
    if(c[x]==1) now++;
}
void del(int x)
{
    c[x]--;
    if(!c[x]) now--;
}
void ins(int p,int v)
{
    if(p>=l && p<=r) add(v),del(a[p]);
    a[p]=v;
}
void solve()
{
    for(int i=1;i<=cnt;i++)
    {
        while(cur<q[i].tim) cur++,ins(w[cur].p,w[cur].v);
        while(cur>q[i].tim) ins(w[cur].p,w[cur].las),cur--;
        while(r<q[i].r) r++,add(a[r]);
        while(r>q[i].r) del(a[r]),r--;
        while(l<q[i].l) del(a[l]),l++;
        while(l>q[i].l) l--,add(a[l]);
        ans[q[i].id]=now;
    }
}
int main()
{
    n=read(),m=read();blo=sqrt(n);
    for(int i=1;i<=n;i++)
    {
        a[i]=tmp[i]=read();
        bl[i]=(i-1)/blo+1;
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%s",ch);x=read(),y=read();
        if(ch[0]=='Q') q[++cnt]=que(x,y,cnt2,cnt);
        else w[++cnt2]=work(x,y,tmp[x]),tmp[x]=y;
    }
    sort(q+1,q+cnt+1);
    solve();
    for(int i=1;i<=cnt;i++) printf("%d\n",ans[i]);
    return 0;
}

三）树上带修莫队

顾名思义，就是把一）和二）结合起来的莫队。听起来似乎很简单，不过代码好长啊。
还要提醒一点：写这种算法时，一定一定要注意常数，因为不管怎么说，莫队+分块还是一个优美的暴力（原始写法是莫队+平面曼哈顿距离MST，复杂度mlogn），常数大的话很容易过不了。尤其注意对操作排序时。一定要按所在块排序，否则八成会T。
例题：BZOJ3052&UOJ58（BZOJ100AC达成）

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#define ll long long
#define inf 0x7f7f7f7f
#define N 100050
#define il inline
using namespace std;
il int read()
{
    int x=0,f=1;
    char c=getchar();
    while(c<'0' || c>'9') {if(c=='-') f=-1;c=getchar();}
    while(c<='9' && c>='0') {x=x*10+c-'0';c=getchar();}
    return x*f;
}
il void swap(int& u,int& v){int t=u;u=v,v=t;}
int n,m,q,v[N],w[N],a,b,fir[N],c[N];
int blo,bl[N],bcnt,top,st[N],cnt[N];
int fa[N][20],h[N];
int cntw,cntq;
ll ans[N],anow;
bool vis[N];
struct nod
{
    int v,nex;
    nod(){}
    nod(int a,int b):v(a),nex(b){}
}e[N<<1];
int tot,hd[N];
il void add(int u,int v){e[++tot]=nod(u,hd[v]);hd[v]=tot;}
struct que
{
    int l,r,tim,id;
    que(){}
    que(int a,int b,int c,int d):l(a),r(b),tim(c),id(d){}
    il void sw(){if(bl[l]>bl[r]) swap(l,r);}
    il bool operator<(const que& b) const
    {
        if(bl[l]!=bl[b.l]) return bl[l]<bl[b.l];
        if(bl[r]!=bl[b.r]) return bl[r]<bl[b.r];
        return tim<b.tim;
    }
}qr[N];
struct work
{
    int x,y,z;
    work(){}
    work(int a,int b,int c):x(a),y(b),z(c){}
}wr[N];
il void init()
{
    for(int j=1;j<=16;j++)
    for(int i=1;i<=n;i++) fa[i][j]=fa[fa[i][j-1]][j-1];
}
il void dfs(int u,int f,int he)
{
    int now=top;
    fa[u][0]=f;h[u]=he;
    for(int i=hd[u];i;i=e[i].nex)
    {
        int v=e[i].v;
        if(v==f) continue;
        dfs(v,u,he+1);
        if(top-now>=blo)
        {
            bcnt++;
            while(top!=now) bl[st[top--]]=bcnt;
        }
    }
    st[++top]=u;
}
il void update(int x)
{
    if(vis[x]) anow-=(ll)w[cnt[c[x]]--]*v[c[x]];
    else anow+=(ll)w[++cnt[c[x]]]*v[c[x]];
    vis[x]^=1;
}
il void modify(int x,int las)
{
    if(vis[x]) 
    {
        update(x);
        c[x]=las;
        update(x);
    }
    else c[x]=las;
}
il void moveto(int x,int y)
{
    while(x!=y)
    {
        if(h[x]<h[y]) swap(x,y);
        update(x);
        x=fa[x][0];
    }
}
il void getans(int x,int y)
{
    update(y);
    ans[qr[x].tim]=anow;
    update(y);
}
il int lca(int u,int v)
{
    if(h[u]<h[v]) swap(u,v);
    int t=h[u]-h[v];
    for(int i=16;i>=0;i--)
    if(t&(1<<i)) u=fa[u][i];
    if(u==v) return u;
    for(int i=16;i>=0;i--)
    if(fa[u][i]!=fa[v][i])
    {
        u=fa[u][i];
        v=fa[v][i];   
    }
    return fa[u][0];
}
int main()
{
    n=read(),m=read(),q=read();
    for(int i=1;i<=m;i++) v[i]=read();
    for(int i=1;i<=n;i++) w[i]=read();
    for(int i=1;i<n;i++)
    {
        a=read(),b=read();
        add(a,b);add(b,a);
    }
    blo=pow(n,2.0/3.0);
    for(int i=1;i<=n;i++) fir[i]=c[i]=read();
    dfs(1,0,0);
    while(top) bl[st[top--]]=bcnt;
    init(); 
    for(int i=1;i<=q;i++)
    {
        int op=read();a=read(),b=read();
        if(!op)
        {
            wr[++cntw]=work(a,fir[a],b);
            fir[a]=b;
        }
        else
        {
            qr[++cntq]=que(a,b,cntq,cntw);
            qr[cntq].sw();
        }
    }
    sort(qr+1,qr+cntq+1);
    int tt=1;
    while(tt<=qr[1].id)
    { 
        modify(wr[tt].x,wr[tt].z);
        tt++;
    }
    moveto(qr[1].l,qr[1].r);
    getans(1,lca(qr[1].l,qr[1].r));
    for(int i=2;i<=cntq;i++)
    {
        while(tt<=qr[i].id) modify(wr[tt].x,wr[tt].z),tt++;
        while(tt>qr[i].id+1) modify(wr[tt-1].x,wr[tt-1].y),tt--;
        moveto(qr[i-1].l,qr[i].l); 
        moveto(qr[i-1].r,qr[i].r); 
        getans(i,lca(qr[i].l,qr[i].r));
    }
    for(int i=1;i<=cntq;i++) printf("%lld\n",ans[i]);
    return 0;
}

P.S.这题最好在UOJ上交，在BZOJ上时限200s，T了等于卡评测。