关于莫队算法的总结

莫队算法是用来骗分的……这个算法的使用前提是

在不强制在线的情况下，对于[l,r],[l',r']的区间询问，我们需要要O(|l-l'|+|r-r'|)次基本操作从[l,r]转移得到[l',r']的答案

可以发现这就是个高能暴力，只不过因为转移方向的优越带来比裸暴力更优的时空复杂度

如果说cdq分治是花费了复杂度干掉了在线，那么莫队就是花费复杂度干掉了区间

对于所有的询问，把当前询问包含的元素叫作当前的处理集合，然后暴力转移维护处理集合来解决下一个区间的询问

首先是最基本的：序列上应用莫队

现在流行的做法是分块，先分成sqrt(n)个块，我们把每个询问按照左端点所在块的编号作为第一关键字，右端点作为第二关键字排序

按这个顺序暴力转移，考虑两种情况

1. 相邻询问第一关键字相等等于x，这样由于第二关键字是递增的，所以所有第一关键字等于x的询问处理总的复杂度是O(n*转移所需复杂度)的，由于第一关键字最多sqrt(n)种取值

2. 第一关键字不等，那么相邻询问转移是O(n*转移所需复杂度)的，但是这样的情况最多出现O(sqrt(n))

所以可以证明复杂度=O(nsqrt(n)*转移所需复杂度)

简单例题：bzoj2038,bzoj3781由于太水我就不放代码了

例题：bzoj3809 比上面稍微难一点，由于颜色也有区间，所以我们可以考虑再对美丽度分块，这样就可以快速统计了，复杂度为O((m+n)sqrt(n)）

下面是比较难的：树上莫队

树怎么分块？请见bzoj1086手把手教树分块，我是orz vfk的分块方式的

树上分块之后，我们就可以树上莫队了

但是等等，不对啊，树上的路径询问怎么转移？

这里我们引入一个东西叫做对称差，说白了就是异或（在处理集合的存在性取反）

我们设S(x,y)代表x,y之间路径的处理集合,h(x)代表节点x的元素

显然对于询问[x,y]，处理集合S(x,y)=S(x,root) xor S(y,root) xor h(lca(x,y));

现在考虑转移到询问[x',y]（先转移x，y类似）,考虑lca只有一个元素，我们可以最后处理

定义T(x,y)=S(x,root) xor S(y,root)

则T(x',y)=S(x‘,root) xor S(y,root)=S(x',root) xor S(x,root) xor S(x,root) xor S(y,root)=T(x',x) xor T(x,y)

所以我们只要把x',x路径上的点存在性取反即可，然后就没了

这里排序有个小技巧，对于询问[x,y]把节点x所在块标号大于y的编号则交换x,y

简单例题：bzoj3757 太水了我就不放代码了

下面是最变态的了：树上带修改莫队

莫队是可以带修改了，学过cdq分治后不难想到把操作时间作为第三关键字排序，这样就搞定了

每次我们不仅要转移询问，还要让处理时间，还是要利用时间戳

注意这里出现了三个关键字，这里证明时间复杂度不难发现分块的大小是n^(2/3)最优,这样复杂度强行O(n^(5/3))，证明的话我就懒得写了

例题：bzoj3052 我很良心的放一个代码

type way=record
       po,next:longint;
     end;
     node=record
       x,y,id:longint;
     end;

var e:array[0..200010] of way;
    q,op:array[0..100010] of node;
    anc:array[0..100010,0..20] of longint;
    d,p,pre,last,prim,st,be,c,w,s,v:array[0..100010] of longint;
    f:array[0..100010] of boolean;
    ans:array[0..100010] of int64;
    test,size,i,j,n,m,x,y,ch,len,t,cur,t1,t0:longint;
    now:int64;
procedure add(x,y:longint);
  begin
    inc(len);
    e[len].po:=y;
    e[len].next:=p[x];
    p[x]:=len;
  end;

procedure dfs(x:longint);
  var i,y,h:longint;
  begin
    h:=t;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if y<>anc[x,0] then
      begin
        anc[y,0]:=x;
        d[y]:=d[x]+1;
        dfs(y);
        if t-h>=size then
        begin
          inc(len);
          while h<>t do
          begin
            be[st[t]]:=len;
            dec(t);
          end;
        end;
      end;
      i:=e[i].next;
    end;
    inc(t);
    st[t]:=x;
  end;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

function cmp(a,b:node):boolean;
  begin
    if (be[a.x]=be[b.x]) and (be[a.y]=be[b.y]) then exit(a.id<b.id);
    if be[a.x]=be[b.x] then exit(be[a.y]<be[b.y]);
    exit(be[a.x]<be[b.x]);
  end;

procedure sort(l,r:longint);
  var i,j:longint;
      x,y:node;
  begin
    i:=l;
    j:=r;
    x:=q[(l+r) shr 1];
    repeat
      while cmp(q[i],x) do inc(i);
      while cmp(x,q[j]) do dec(j);
      if not(i>j) then
      begin
        y:=q[i]; q[i]:=q[j]; q[j]:=y;
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

procedure del(x:longint);
  begin
    now:=now-int64(v[x])*int64(w[s[x]]);
    dec(s[x]);
  end;

procedure ins(x:longint);
  begin
    inc(s[x]);
    now:=now+int64(v[x])*int64(w[s[x]]);
  end;

procedure timec(i:longint);
  begin
    while (cur<t0) and (op[cur+1].id<q[i].id) do
    begin
      inc(cur);
      if f[op[cur].x] then del(c[op[cur].x]);
      c[op[cur].x]:=op[cur].y;
      if f[op[cur].x] then ins(op[cur].y);
    end;
    while op[cur].id>q[i].id do
    begin
      if f[op[cur].x] then del(c[op[cur].x]);
      if pre[cur]=0 then c[op[cur].x]:=prim[op[cur].x]
      else c[op[cur].x]:=op[pre[cur]].y;
      if f[op[cur].x] then ins(c[op[cur].x]);
      dec(cur);
    end;
  end;

procedure rev(x:longint);
  begin
    if not f[x] then ins(c[x])
    else del(c[x]);
    f[x]:=not f[x];
  end;

procedure work(x,y:longint);
  begin
    while x<>y do
    begin
      if d[x]>d[y] then
      begin
        rev(x);
        x:=anc[x,0];
      end
      else begin
        rev(y);
        y:=anc[y,0];
      end;
    end;
  end;

function lca(x,y:longint):longint;
  var i:longint;
  begin
    if x=y then exit(x);
    if d[x]<d[y] then swap(x,y);
    if d[x]>d[y] then
    begin
      for i:=trunc(ln(d[x])/ln(2)) downto 0 do
        if d[x]-1 shl i>=d[y] then x:=anc[x,i];
    end;
    if x=y then exit(x);
    for i:=trunc(ln(d[y])/ln(2)) downto 0 do
      if anc[x,i]<>anc[y,i] then
      begin
        x:=anc[x,i];
        y:=anc[y,i];
      end;
    exit(anc[x,0]);
  end;

procedure get(i:longint);
  var z:longint;
  begin
    z:=lca(q[i].x,q[i].y);
    rev(z);
    ans[q[i].id]:=now;
    rev(z);
  end;

begin
  readln(n,m,test);
  size:=0;
  while size/n*size/n*size<1 do inc(size);
  dec(size);
  for i:=1 to m do
    read(v[i]);
  for i:=1 to n do
    read(w[i]);
  for i:=1 to n-1 do
  begin
    readln(x,y);
    add(x,y);
    add(y,x);
  end;
  len:=0;
  dfs(1);
  while t>0 do
  begin
    be[st[t]]:=len;
    dec(t);
  end;
  for j:=1 to trunc(ln(n)/ln(2)) do
    for i:=1 to n do
    begin
      x:=anc[i,j-1];
      anc[i,j]:=anc[x,j-1];
    end;
  for i:=1 to n do
  begin
    read(c[i]);
    prim[i]:=c[i];  //初始颜色
  end;
  for i:=1 to test do
  begin
    readln(ch,x,y);
    if ch=0 then
    begin
      inc(t0);
      op[t0].x:=x; op[t0].y:=y; op[t0].id:=i;
      pre[t0]:=last[x];
      last[x]:=t0;  //记录上一个关于点x的操作，方便解决时间倒流
    end
    else begin
      inc(t1);
      q[t1].x:=x; q[t1].y:=y; q[t1].id:=i;
      if be[q[t1].x]>be[q[t1].y] then swap(q[t1].x,q[t1].y);
    end;
  end;
  sort(1,t1);
  timec(1);
  work(q[1].x,q[1].y);
  get(1);
  for i:=2 to t1 do
  begin
    timec(i);
    work(q[i-1].x,q[i].x);
    work(q[i-1].y,q[i].y);
    get(i);
  end;
  for i:=1 to test do
    if ans[i]<>0 then writeln(ans[i]);
end.

总之莫队是一个有效的骗分神器，但是他太一般化了，所以一些特殊的问题无法做的更好，尽量不要一上来就写莫队