神奇的莫队（含树上莫队）

稀饭bzoj的同学，例题的bzoj编号请自行寻找…..

普通莫队

莫队是一种很暴力的算法……
是一种基于分块思想的算法…….
莫队的思路是把询问排序之后处理可以优化时间复杂度降低~~
大家都知道当前的$l-r$的这个区间已经处理出来了，之后求$l'-r'$这个区间，就可以用$|l'-l|+|r'-r|$的复杂度求出来，所以只要排序排的好，就很容易做出来。
排序的方法是：以左节点所在的块为第一关键字，右边为第二关键字从小到大排序。
例题洛谷1972代码（跟hzwer学的）：

#include<iostream>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int read(){
    int q=0;char ch=' ';
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')q=q*10+ch-'0',ch=getchar();
    return q;
}
struct node{int l,r,id;}q[200005];
int c[50005],col[1000005],pos[50005],ans[200005];
int n,m,sqn,bj;
bool cmp(node a,node b){
    if(pos[a.l]==pos[b.l])return a.r<b.r;
    else return a.l<b.l;
}
void solve(){
    int he=1,ta=0,i;
    for(i=1;i<=m;i++){
        for(;ta<q[i].r;ta++)if(!col[c[ta+1]]++)bj++;
        for(;ta>q[i].r;ta--)if(!--col[c[ta]])bj--;
        for(;he<q[i].l;he++)if(!--col[c[he]])bj--;
        for(;he>q[i].l;he--)if(!col[c[he-1]]++)bj++;
        ans[q[i].id]=bj;
    }
}
int main()
{
    int i,j;
    n=read();sqn=sqrt(n);
    for(i=1;i<=n;i++)c[i]=read();
    for(i=1;i<=n;i++)pos[i]=(i-1)/sqn+1;
    m=read();
    for(i=1;i<=m;i++)
    {q[i].l=read();q[i].r=read();q[i].id=i;}
    sort(q+1,q+1+m,cmp);solve();
    for(i=1;i<=m;i++)printf("%d\n",ans[i]);
    return 0;
}

例题：洛谷2709，bzoj2038。
还有bzoj3289，求区间逆序对，就是莫队套树状数组+离散化，但是在修改那一块要思考思考。
对于挪动区间右端，改变的贡献是已经在树状数组里存在的严格大于其权值的数的数量，而对于挪动区间左端，改变的贡献是已经在树状数组里存在的严格小于其权值的数的数量，这个的写法见代码

#include<iostream>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
#define ll long long
int read(){
    int q=0;char ch=' ';
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')q=q*10+ch-'0',ch=getchar();
    return q;
}
int w[50005],ww[50005],pos[50005],num[50005];
long long ans[50005];
int n,m,tot,sqn;
struct node{int s,t,id;}q[50005];
bool cmp(node a,node b){
    if(pos[a.s]==pos[b.s])return a.t<b.t;
    return a.s<b.s;
}
int lowbit(int x){return x&(-x);}
void add(int x,int val)//树状数组：插入
{while(x<=tot){num[x]+=val;x+=lowbit(x);}}
ll find(int x){//树状数组：查询
    ll re=0;
    while(x){re+=num[x];x-=lowbit(x);}
    return re;
}
void solve(){//莫队莫队！
    int i,he=1,ta=0;long long re=0;
    for(i=1;i<=m;i++){
        for(;ta<q[i].t;ta++){re+=find(tot)-find(w[ta+1]);add(w[ta+1],1);}
        for(;ta>q[i].t;ta--){re-=find(tot)-find(w[ta]);add(w[ta],-1);}
        for(;he<q[i].s;he++){re-=find(w[he]-1);add(w[he],-1);}
        for(;he>q[i].s;he--){re+=find(w[he-1]-1);add(w[he-1],1);}
        ans[q[i].id]=re;
    }
}
int main()
{
    int i,j,bj,kl;
    n=read();
    sqn=sqrt(n);for(i=1;i<=n;i++)pos[i]=(i-1)/sqn+1;
    for(i=1;i<=n;i++){w[i]=read();ww[i]=w[i];}
    sort(ww+1,ww+1+n);tot=1;
    for(i=1;i<=n;i++)if(ww[tot]!=ww[i])ww[++tot]=ww[i];
    for(i=1;i<=n;i++)w[i]=lower_bound(ww+1,ww+1+tot,w[i])-ww;
    m=read();//前面都是离散化
    for(i=1;i<=m;i++)q[i].s=read(),q[i].t=read(),q[i].id=i;
    sort(q+1,q+1+m,cmp);solve();
    for(i=1;i<=m;i++)printf("%lld\n",ans[i]);
    return 0;
}

带修改莫队

这个多记录一些东西就可以了….时间复杂度略高一点。
由于博主是个傻逼，所以一开始写的时候没注意带修莫队的块大小应为$n^{\frac{2}{3}}$，排序方式是以左端点所在的块为第一关键字，右端点所在的块为第二关键字，上一个修改操作的时间为第三关键字排序，而使用了普通莫队的方法。希望大家不要犯和傻逼博主一样的错误，以免考试时正解惨变暴力分。
复杂度是$O(n^{\frac{5}{3}})$
具体看代码吧。洛谷1903

#include<iostream>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int read(){
    int q=0;char ch=' ';
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')q=q*10+ch-'0',ch=getchar();
    return q;
}
char in(){
    char ch=' ';
    while(ch!='Q'&&ch!='R')ch=getchar();
    return ch;
}
int n,m,sqn,cnt1,cnt2;
int a[10005],pos[10005],las[10005],ans[10005],sum[1000005];
struct node{int l,r,id1,id2;}q[10005];
struct slo{int x,se,fa;}gs[10005];//gs:修改
bool cmp(node x,node y) {
    if(pos[x.l]!=pos[y.l]) return pos[x.l]<pos[y.l];
    if(pos[x.r]!=pos[y.r]) return pos[x.r]<pos[y.r];
    return x.id2<y.id2;
}
void work(){
    int i,j,bj=0,tt=0,ll=1,rr=0;
    for(i=1;i<=cnt1;i++){//更改颜色中....
        for(;tt<q[i].id2;tt++){
            if(ll<=gs[tt+1].x&&gs[tt+1].x<=rr){
                if(!--sum[a[gs[tt+1].x]])bj--;
                if(!sum[gs[tt+1].se]++)bj++;
            }
            a[gs[tt+1].x]=gs[tt+1].se;
        }
        for(;tt>q[i].id2;tt--){
            if(ll<=gs[tt].x&&gs[tt].x<=rr){
                if(!--sum[a[gs[tt].x]])bj--;
                if(!sum[gs[tt].fa]++)bj++;
            }
            a[gs[tt].x]=gs[tt].fa;
        }
        //普通莫队
        for(;rr<q[i].r;rr++)if(!sum[a[rr+1]]++)bj++;
        for(;rr>q[i].r;rr--)if(!--sum[a[rr]])bj--;
        for(;ll<q[i].l;ll++)if(!--sum[a[ll]])bj--;
        for(;ll>q[i].l;ll--)if(!sum[a[ll-1]]++)bj++;
        ans[q[i].id1]=bj;
    }
}
int main()
{
    int i,j;
    n=read();m=read();sqn=pos(n,2.0/3.0);
    for(i=1;i<=n;i++)
        {a[i]=read();las[i]=a[i];pos[i]=(i-1)/sqn+1;}
    for(i=1;i<=m;i++)
        if(in()=='Q'){
        cnt1++;q[cnt1].l=read();q[cnt1].r=read();
        q[cnt1].id1=cnt1;q[cnt1].id2=cnt2;
    }
        else {
        cnt2++;gs[cnt2].x=read();gs[cnt2].se=read();//fa:记录在变色前的颜色
        gs[cnt2].fa=las[gs[cnt2].x];las[gs[cnt2].x]=gs[cnt2].se;//se：变成什么颜色
    }
    sort(q+1,q+1+cnt1,cmp);work();
    for(i=1;i<=cnt1;i++)printf("%d\n",ans[i]);
    return 0;
}

树分块

bzoj1086
做法很简单：从任意节点开始dfs，如果某个节点有几棵子树的节点数已经大于B了，就直接划一个省出来，首都就是当前节点。否则就把所有节点加入栈里面，最后几个节点都放进最后一个省里，因为显然这个省的节点数不会超过2B
所以说这题其实挺水的……就是具有迷惑性。

#include<iostream>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int read(){
    int q=0;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')q=q*10+ch-'0',ch=getchar();
    return q;
}
int n,b,tot,top,cnt;
int h[1005],ne[2005],to[2005],pos[1005],sum[1005];
int stk[1005],mid[1005];
void add(int x,int y){to[++tot]=y;ne[tot]=h[x];h[x]=tot;}
void dfs(int x,int las){
    int i;stk[++top]=x;
    for(i=h[x];i;i=ne[i]){
        if(to[i]==las)continue;
        dfs(to[i],x);
        if(sum[x]+sum[to[i]]>=b){
            cnt++;sum[x]=0;
            while(stk[top]!=x){pos[stk[top]]=cnt;top--;}
            mid[cnt]=x;
        }
        else sum[x]+=sum[to[i]];
    }
    sum[x]++;
}
int main()
{
    int i,j,x,y;
    n=read();b=read();
    if(n<b){printf("0");return 0;}
    for(i=1;i<n;i++){x=read();y=read();add(x,y);add(y,x);}
    dfs(1,-1);while(top){pos[stk[top]]=cnt;top--;}
    printf("%d\n",cnt);
    for(i=1;i<=n;i++)printf("%d ",pos[i]);
    printf("\n");
    for(i=1;i<=cnt;i++)printf("%d ",mid[i]);
    return 0;
}

树上莫队

树上莫队要怎么分块呢？网上流传的版本很多是按照上面那种方式分块，但是（目前正在版刷bzoj树形dp题的）树王表示：

如果出个菊花图的话，一下子就卡掉了呀。

所以本蒟蒻就用了dfs序分块，首先我们记录每一个节点的dfs序，如下图：

假如x和y是在同一条链上，比如dfs序为（1，16）和（3，4）的那两个节点，我们就记录1,3.
假如x和y不是在同一条链上，比如dfs序为(2,5)和(9,14）的那两个节点，记录5,9（具体怎么记录看代码），接着你会发现这个区间里没有它们的lca，所以lca要单独计算。
然后访问记录区间内的,dfs序代表的节点，如果某一个节点访问了两次，就等于没有访问，这样就可以将路径弄出来了，不信去图上试一试。不过如果遇上第二种情况，那么我们的lca就并没有被计算，需要单独计算，不过计算完了之后一定要再把lca删掉，因为本来我们的序列里就不用它啊。
剩下的就是普通莫队了。
例题：bzoj3052(codevs1987)
网上流传的和上面那个树分块方式很像的分块在bzoj运行时间大概在100s左右，我这份大概在40s左右，但是空间大了3倍……
树王说：

你这代码卡卡空间就卡掉了啊，还有为什么不用树剖lca呢。

我……不会树剖……

#include<iostream>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int read(){
    int q=0;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9')q=q*10+ch-'0',ch=getchar();
    return q;
}
const int maxn=1000005;
int n,m,wen,tot,sqn,tim,c1,c2;
int w[maxn],v[maxn],c[maxn],las[maxn],hav[maxn];
int h[maxn],ne[maxn<<1],to[maxn<<1];
int in[maxn],le[maxn],is[maxn<<1],fa[maxn][24],bin[24],dep[maxn],pos[maxn<<1];
long long ans[maxn],re;bool vis[maxn];
struct node{int l,r,t,id;}q[maxn];
struct nn{int bj,col,pre;}gs[maxn];
void add(int x,int y){to[++tot]=y;ne[tot]=h[x];h[x]=tot;}
void dfs(int x,int sy){//dfs序！ :)
    tim++;in[x]=tim;is[tim]=x;
    for(int i=1;bin[i]<=dep[x];i++)fa[x][i]=fa[fa[x][i-1]][i-1];
    for(int i=h[x];i;i=ne[i]){
        if(to[i]==sy)continue;
        fa[to[i]][0]=x;dep[to[i]]=dep[x]+1;dfs(to[i],x);
    }
    tim++;le[x]=tim;is[tim]=x;
}
int lca(int x,int y){//倍增求lca! ovo
    int i;
    if(dep[x]<dep[y])swap(x,y);
    for(i=17;i>=0;i--)
        if(dep[fa[x][i]]>=dep[y]&&fa[x][i])x=fa[x][i];
    if(x==y)return x;
    for(i=17;i>=0;i--)
        if(fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
void cal(int x){//如果访问过了，就减去，否则加上 
    int tmp=c[x];
    if(vis[x]){re-=(long long)v[tmp]*w[hav[tmp]];hav[tmp]--;}
    else {hav[tmp]++;re+=(long long)v[tmp]*w[hav[tmp]];}
    vis[x]^=1;
}
void chan(int x,int y){
    if(vis[x]){cal(x);c[x]=y;cal(x);}
    else c[x]=y;
}
void solve(){//莫队qwq~
    int i,he=1,ta=0,tt=0,tmp;
    for(i=1;i<=c1;i++){
        for(;tt<q[i].t;tt++)chan(gs[tt+1].bj,gs[tt+1].col);
        for(;tt>q[i].t;tt--)chan(gs[tt].bj,gs[tt].pre);
        for(;ta<q[i].r;ta++)cal(is[ta+1]);
        for(;ta>q[i].r;ta--)cal(is[ta]);
        for(;he<q[i].l;he++)cal(is[he]);
        for(;he>q[i].l;he--)cal(is[he-1]);
        tmp=lca(is[he],is[ta]);//lca单独加上，但是最终要变回来
        if(tmp!=is[he]&&tmp!=is[ta]){cal(tmp);ans[q[i].id]=re;cal(tmp);}
        else ans[q[i].id]=re;
    }
}
bool cmp(node a,node b){//sort 比较函数
    if(pos[a.l]==pos[b.l]&&pos[a.r]==pos[b.r])return a.t<b.t;
    if(pos[a.l]==pos[b.l])return pos[a.r]<pos[b.r];
    return pos[a.l]<pos[b.l];
}
int main()
{
    int i,j,x,y,z;
    bin[0]=1;for(i=1;i<=17;i++)bin[i]=bin[i-1]<<1;//bin:倍增求lca的时候用于加速
    n=read();m=read();wen=read();
    for(i=1;i<=m;i++)v[i]=read();
    for(i=1;i<=n;i++)w[i]=read();
    for(i=1;i<n;i++){x=read();y=read();add(x,y);add(y,x);}
    for(i=1;i<=n;i++)c[i]=read(),las[i]=c[i];
    sqn=pow(n,2.0/3);dfs(1,-1);
    for(i=1;i<=tim;i++)pos[i]=(i-1)/sqn;
    for(i=1;i<=wen;i++){
        z=read();
        if(z){
            x=read();y=read();
            if(in[x]>in[y])swap(x,y);
            c1++;q[c1].r=in[y];q[c1].id=c1;q[c1].t=c2;
            if(lca(x,y)==x)q[c1].l=in[x];
            else q[c1].l=le[x];
        }
        else {
            c2++;x=read();y=read();
            gs[c2].bj=x;gs[c2].col=y;gs[c2].pre=las[x];las[x]=y;
        }
    }
    sort(q+1,q+1+c1,cmp);solve();
    for(i=1;i<=c1;i++)printf("%lld\n",ans[i]);
    return 0;
}