bzoj 2243 树链剖分

2013-11-19 16:21

原题传送门http://www.lydsy.com/JudgeOnline/problem.php?id=2243

树链剖分，用线段树记录该区间的颜色段数，左右端点颜色数，然后就OK了

 //By BLADEVIL
 type
     rec                                 =record
         sum, left, right, succ, pred    :longint;
         lazy                            :longint;
     end;

 var
     n                                   :longint;
     pre, other                          :array[..] of longint;
     last                                :array[..] of longint;
     m                                   :longint;
     color                               :array[..] of longint;
     father, size, max_son               :array[..] of longint;
     dep, top, a, num                    :array[..] of longint;
     tot                                 :longint;
     flag                                :array[..] of boolean;
     l                                   :longint;
     t                                   :array[..] of rec;

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

 procedure connect(x,y:longint);
 begin
     inc(l);
     pre[l]:=last[x];
     last[x]:=l;
     other[l]:=y;
 end;

 procedure dfs(x:longint);
 var
     q, p                                :longint;
 begin
     size[x]:=;
     q:=last[x];
     while q<> do
     begin
         p:=other[q];
         if not flag[p] then
         begin
             father[p]:=x;
             flag[p]:=true;
             dfs(p);
             inc(size[x],size[p]);
             if size[max_son[x]]<size[p] then max_son[x]:=p;
         end;
         q:=pre[q];
     end;
 end;

 procedure make(x,t,depth:longint);
 var
     q, p                                :longint;
 begin
     inc(tot);
     num[x]:=tot;
     top[x]:=t;
     a[tot]:=color[x];
     dep[x]:=depth;
     if (max_son[x]<>) and (not flag[max_son[x]]) then
     begin
         flag[max_son[x]]:=true;
         make(max_son[x],t,depth);
     end;
     q:=last[x];
     while q<> do
     begin
         p:=other[q];
         if not flag[p] then
         begin
             flag[p]:=true;
             make(p,p,depth+);
         end;
         q:=pre[q];
     end;
 end;

 procedure build(x,l,r:longint);
 var
     mid                                 :longint;
 begin
     t[x].left:=l; t[x].right:=r;
     if l=r then
     begin
         t[x].sum:=;
         t[x].succ:=a[l];
         t[x].pred:=a[l];
         exit;
     end;
     mid:=(l+r) div ;
     build(x*,l,mid);
     build(x*+,mid+,r);
     t[x].succ:=t[x*].succ;
     t[x].pred:=t[x*+].pred;
     if t[x*].pred=t[x*+].succ then
         t[x].sum:=t[x*].sum+t[x*+].sum- else
         t[x].sum:=t[x*].sum+t[x*+].sum;
 end;    

 procedure init;
 var
     i                                   :longint;
     x, y                                :longint;

 begin
     read(n,m);
     for i:= to n do read(color[i]);
     for i:= to n- do
     begin
         read(x,y);
         connect(x,y);
         connect(y,x);
     end;
     flag[]:=true;
     dfs();
     fillchar(flag,sizeof(flag),false);
     flag[]:=true;
     make(,,);
     build(,,n);
 end;

 procedure change(x,l,r,z:longint);
 var
     mid                                 :longint;
 begin
     if t[x].lazy<> then
     begin
 t[x*].lazy:=t[x].lazy;
         t[x*].sum:=;
         t[x*].succ:=t[x].lazy;
         t[x*].pred:=t[x].lazy;
         t[x*+].lazy:=t[x].lazy;
         t[x*+].sum:=;
         t[x*+].succ:=t[x].lazy;
         t[x*+].pred:=t[x].lazy;
         t[x].lazy:=;
     end;
     if (t[x].left=l) and (t[x].right=r) then
     begin
         t[x].lazy:=z;
         t[x].sum:=;
         t[x].succ:=z;
         t[x].pred:=z;
         exit;
     end;
     with t[x] do mid:=(left+right) div ;
     if mid<l then change(x*+,l,r,z) else
     if mid>=r then change(x*,l,r,z) else
     begin
         change(x*,l,mid,z);
         change(x*+,mid+,r,z);
     end;
     t[x].succ:=t[x*].succ;
     t[x].pred:=t[x*+].pred;
     if t[x*].pred=t[x*+].succ then
         t[x].sum:=t[x*].sum+t[x*+].sum- else
         t[x].sum:=t[x*].sum+t[x*+].sum;
 end;

 function ask(x,l,r:longint):rec;
 var
     mid                                 :longint;
 t1, t2     :rec;
 begin
     if t[x].lazy<> then
     begin
         t[x*].lazy:=t[x].lazy;
         t[x*].sum:=;
         t[x*].succ:=t[x].lazy;
         t[x*].pred:=t[x].lazy;
         t[x*+].lazy:=t[x].lazy;
         t[x*+].sum:=;
         t[x*+].succ:=t[x].lazy;
         t[x*+].pred:=t[x].lazy;
         t[x].lazy:=;
     end;

     if (t[x].left=l) and (t[x].right=r) then
     begin
         ask.succ:=t[x].succ;
         ask.pred:=t[x].pred;
         ask.sum:=t[x].sum;
         exit;
     end;

     with t[x] do mid:=(left+right) div ;
     if mid<l then
     begin
 t2:=ask(x*+,l,r);
         ask.succ:=t2.succ;
         ask.pred:=t2.pred;
         ask.sum:=t2.sum
     end else
     if mid>=r then
     begin
 t1:=ask(x*,l,r);
         ask.succ:=t1.succ;
         ask.pred:=t1.pred;
         ask.sum:=t1.sum
     end else
     begin
 t1:=ask(x*,l,mid);
 t2:=ask(x*+,mid+,r);
         ask.succ:=t1.succ;
         ask.pred:=t2.pred;
         if t1.pred=t2.succ then
             ask.sum:=t1.sum+t2.sum- else
             ask.sum:=t1.sum+t2.sum;
     end;
 end;

 procedure paint(x,y,z:longint);
 begin
     if dep[x]>dep[y] then swap(x,y);
     while dep[x]<dep[y] do
     begin
         change(,num[top[y]],num[y],z);
         y:=father[top[y]];
     end;
     while top[x]<>top[y] do
     begin
         change(,num[top[x]],num[x],z);
         change(,num[top[y]],num[y],z);
         x:=father[top[x]];
         y:=father[top[y]];
     end;
     x:=num[x];
     y:=num[y];
     if x>y then swap(x,y);
     change(,x,y,z);
 end;

 procedure query(x,y:longint);
 var
     ans                                 :longint;
     a, b                                :longint;
 begin
     ans:=;
     if dep[x]>dep[y] then swap(x,y);
     while dep[x]<dep[y] do
     begin
         ans:=ans+ask(,num[top[y]],num[y]).sum;
         a:=ask(,num[top[y]],num[top[y]]).succ;
         b:=ask(,num[father[top[y]]],num[father[top[y]]]).pred;
         if a=b then dec(ans);
         y:=father[top[y]];
     end;
     while top[x]<>top[y] do
     begin
         ans:=ans+ask(,num[top[y]],num[y]).sum;
         a:=ask(,num[top[y]],num[top[y]]).succ;
         b:=ask(,num[father[top[y]]],num[father[top[y]]]).pred;
         if a=b then dec(ans);
         ans:=ans+ask(,num[top[x]],num[x]).sum;
         a:=ask(,num[top[x]],num[top[x]]).succ;
         b:=ask(,num[father[top[x]]],num[father[top[x]]]).pred;
         if a=b then dec(ans);
         x:=father[top[x]];
         y:=father[top[y]];
     end;
     x:=num[x];
     y:=num[y];
     if x>y then swap(x,y);
     ans:=ans+ask(,x,y).sum;
     writeln(ans);
 end;

 procedure main;
 var
     i                                   :longint;
     c                                   :char;
     x, y, z                             :longint;

 begin
     readln;
     for i:= to m do
     begin
         read(c);
         if c='Q' then
         begin
             readln(x,y);
             query(x,y)
         end else
         begin
             readln(x,y,z);
             paint(x,y,z);
         end;
     end;
 end;

 begin
     init;
     main;
 end.