神奇的莫队（含树上莫队）
稀饭bzoj的同学，例题的bzoj编号请自行寻找…..
普通莫队
莫队是一种很暴力的算法……
是一种基于分块思想的算法…….
莫队的思路是把询问排序之后处理可以优化时间复杂度降低~~
大家都知道当前的 l−r l − r 的这个区间已经处理出来了，之后求 l′−r′ l ′ − r ′ 这个区间，就可以用 |l′−l|+|r′−r| | l ′ − l | + | r ′ − r | 的复杂度求出来，所以只要排序排的好，就很容易做出来。
排序的方法是：以左节点所在的块为第一关键字，右边为第二关键字从小到大排序。
例题洛谷1972代码（跟hzwer学的）：
#includeelse return a.lvoid solve(){
int he=1,ta=0,i;
for(i=1;i<=m;i++){
for(;taif(!col[c[ta+1]]++)bj++;
for(;ta>q[i].r;ta--)if(!--col[c[ta]])bj--;
for(;heif(!--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，求区间逆序对，就是莫队套树状数组+离散化，但是在修改那一块要思考思考。
对于挪动区间右端，改变的贡献是已经在树状数组里存在的严格大于其权值的数的数量，而对于挪动区间左端，改变的贡献是已经在树状数组里存在的严格小于其权值的数的数量，这个的写法见代码
#includereturn a.sint 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(;ta1]);add(w[ta+1],1);}
for(;ta>q[i].t;ta--){re-=find(tot)-find(w[ta]);add(w[ta],-1);}
for(;he1);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;
} 带修改莫队
这个多记录一些东西就可以了….时间复杂度略高一点。
由于博主是个傻逼，所以一开始写的时候没注意带修莫队的块大小应为 n23 n 2 3 ，排序方式是以左端点所在的块为第一关键字，右端点所在的块为第二关键字，上一个修改操作的时间为第三关键字排序，而使用了普通莫队的方法。希望大家不要犯和傻逼博主一样的错误，以免考试时正解惨变暴力分。
复杂度是 O(n53) O ( n 5 3 )
具体看代码吧。洛谷1903
#includeif(pos[x.r]!=pos[y.r]) return pos[x.r]return x.id2void work(){
int i,j,bj=0,tt=0,ll=1,rr=0;
for(i=1;i<=cnt1;i++){//更改颜色中....
for(;ttif(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(;rrif(!sum[a[rr+1]]++)bj++;
for(;rr>q[i].r;rr--)if(!--sum[a[rr]])bj--;
for(;llif(!--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
所以说这题其实挺水的……就是具有迷惑性。
#includeprintf("0");return 0;}
for(i=1;i1,-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呢。
我……不会树剖……
#includefor(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(;tt1].bj,gs[tt+1].col);
for(;tt>q[i].t;tt--)chan(gs[tt].bj,gs[tt].pre);
for(;ta1]);
for(;ta>q[i].r;ta--)cal(is[ta]);
for(;hefor(;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.tif(pos[a.l]==pos[b.l])return pos[a.r]return pos[a.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;ifor(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;
}