bzoj4817: [Sdoi2017]树点涂色

4817: [Sdoi2017]树点涂色

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 435  Solved: 250
[Submit][Status][Discuss]

Description

Bob有一棵n个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。定义一条路

径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作：

1 x:

把点x到根节点的路径上所有的点染上一种没有用过的新颜色。

2 x y:

求x到y的路径的权值。

3 x y:

在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。

Bob一共会进行m次操作

 

Input

第一行两个数n,m。

接下来n-1行，每行两个数a,b，表示a与b之间有一条边。

接下来m行，表示操作，格式见题目描述

1<=n,m<=100000

 

Output

每当出现2,3操作，输出一行。

如果是2操作，输出一个数表示路径的权值

如果是3操作，输出一个数表示权值的最大值

 

Sample Input

5 6
1 2
2 3
3 4
3 5
2 4 5
3 3
1 4
2 4 5
1 5
2 4 5

Sample Output

3
4
2
2

题解

　　我们用实边代表边两端颜色相同，虚边代表两端颜色不同，1操作就是一次access的过程。

　　在dfs序上，我们用线段树维护每个点到根路径上的虚边数目，一开始每个点的值都是自己的深度。每次access虚实边转换的时候，我们就把由实变虚的边整个子树的值+1，由虚变实的边整个子树的值-1。

　　2操作就是u的值+v的值-2*lca(u,v)的值+1。

　　3操作就是区间求max

program j01;
const maxn=100086;
var t:array[0..maxn]of record son:array[0..1]of longint;fa:longint; end;
    f:array[0..4*maxn]of record tag,mx:longint; end;
    st:array[0..20,0..2*maxn]of longint;
    dep,home,dfn,ed,id,fir:array[0..maxn]of longint;
    q,next,bin:array[0..2*maxn]of longint;
    head:array[0..maxn]of longint;
    u,v,op,n,m,i,tt,tot,time,lc:longint;
    ll,rr,dd:longint;
    
procedure swap(var a,b:longint);inline;var c:longint;begin c:=a;a:=b;b:=c; end;
function max(a,b:longint):longint;inline;begin if a>b then exit(a) else exit(b); end;
procedure addd(var h:longint;v:longint);inline;begin inc(tt);q[tt]:=v;next[tt]:=h;h:=tt; end;

procedure dfs(i:longint);
var j:longint;
begin
    inc(tot);dfn[i]:=tot;id[tot]:=i;
    inc(time);st[0,time]:=i;fir[i]:=time;
    j:=head[i];
    while j>0 do
    begin
        if(q[j]<>t[i].fa)then
        begin
            dep[q[j]]:=dep[i]+1;t[q[j]].fa:=i;
            dfs(q[j]);inc(time);st[0,time]:=i;
        end;
        j:=next[j];
    end;
    ed[i]:=tot;
end;
{segement tree-------------------------------------------------------}

procedure build(i,l,r:longint);
var mid:longint;
begin
    f[i].tag:=0;if l=r then begin f[i].mx:=dep[id[l]]; exit; end;
    mid:=(l+r)div 2;build(i*2,l,mid);build(i*2+1,mid+1,r);f[i].mx:=max(f[i*2].mx,f[i*2+1].mx);
end;

procedure pushdown(i:longint);
var tag:longint;
begin
    if f[i].tag=0 then exit;tag:=f[i].tag;f[i].tag:=0;
    inc(f[i*2].tag,tag);inc(f[i*2].mx,tag);
    inc(f[i*2+1].tag,tag);inc(f[i*2+1].mx,tag);
end;

procedure change(i,l,r:longint);
var mid:longint;
begin
    if(ll<=l)and(r<=rr)then begin inc(f[i].tag,dd);inc(f[i].mx,dd);exit; end;
    mid:=(l+r)div 2;pushdown(i);
    if ll<=mid then change(i*2,l,mid);
    if mid+1<=rr then change(i*2+1,mid+1,r);
    f[i].mx:=max(f[i*2].mx,f[i*2+1].mx);
end;

function find(i,l,r,ps:longint):longint;
var mid:longint;
begin
    if l=r then exit(f[i].mx);
    mid:=(l+r)div 2;pushdown(i);
    if ps<=mid then exit(find(i*2,l,mid,ps)) else exit(find(i*2+1,mid+1,r,ps));
end;

function ask(i,l,r:longint):longint;
var mid,res:longint;
begin
    if(ll<=l)and(r<=rr)then exit(f[i].mx);
    mid:=(l+r)div 2;pushdown(i);res:=0;
    if ll<=mid then res:=max(res,ask(i*2,l,mid));
    if mid+1<=rr then res:=max(res,ask(i*2+1,mid+1,r));
    exit(res);
end;

{segment tree--------------------------------------------------------}

{st_lca--------------------------------------------------------------}

function min_st(a,b:longint):longint;inline;begin if dep[a]<dep[b] then exit(a) else exit(b); end;

procedure getst;
var i,j:longint;
begin
    bin[1]:=0;
    for i:=2 to time do
        if i and(i-1)=0 then bin[i]:=bin[i-1]+1 else bin[i]:=bin[i-1];
    for i:=1 to bin[time] do
        for j:=1 to time+1-(1 shl i) do 
            st[i,j]:=min_st(st[i-1,j],st[i-1,j+(1 shl (i-1))]);
end;

function lca(u,v:longint):longint;
var k:longint;
begin
    u:=fir[u];v:=fir[v];
    if u>v then swap(u,v);k:=bin[v-u+1];
    exit(min_st(st[k,u],st[k,v+1-(1 shl k)]));
end;

{st_lca--------------------------------------------------------------}

{lct-----------------------------------------------------------------}

function isroot(i:longint):boolean;inline;begin exit((t[t[i].fa].son[0]<>i)and(t[t[i].fa].son[1]<>i));end;

procedure rotate(i,dd:longint);
var k,l:longint;
begin
    k:=t[i].son[dd];l:=t[i].fa;
    if not isroot(i) then t[l].son[ord(t[l].son[1]=i)]:=k;t[k].fa:=l;
    t[i].son[dd]:=t[k].son[1-dd];t[t[k].son[1-dd]].fa:=i;
    t[k].son[1-dd]:=i;t[i].fa:=k;
end;

procedure splay(i:longint);
var p,dd:longint;
begin
    while not isroot(i) do
    begin
        p:=t[i].fa;
        if isroot(p) then begin rotate(p,ord(t[p].son[1]=i));break; end;
        dd:=ord(t[t[p].fa].son[1]=p);
        if t[p].son[dd]=i then rotate(t[p].fa,dd) else rotate(t[i].fa,1-dd);
        rotate(t[i].fa,dd);
    end;
end;

function findmn(i:longint):longint;
begin
    if i=0 then exit(0);
    while t[i].son[0]>0 do i:=t[i].son[0];exit(i);
end;

procedure access(x:longint);
var y,u:longint;
begin
    y:=0;
    while x>0 do
    begin
        splay(x);u:=findmn(t[x].son[1]);
        if u>0 then begin ll:=dfn[u];rr:=ed[u];dd:=1;change(1,1,n); end;
        t[x].son[1]:=y;u:=findmn(y);
        if u>0 then begin ll:=dfn[u];rr:=ed[u];dd:=-1;change(1,1,n); end;
        y:=x;x:=t[x].fa;
    end;
end;

{lct-----------------------------------------------------------------}
    
begin
    assign(input,'1.in');reset(input);
    readln(n,m);
    fillchar(head,sizeof(head),0);tt:=0;
    for i:=1 to n-1 do
    begin
        readln(u,v);addd(head[u],v);addd(head[v],u);
    end;
    dep[1]:=0;t[1].fa:=0;time:=0;tot:=0;dfs(1);
    build(1,1,n);getst;
    for i:=1 to m do
    begin
        read(op);
        if op=1 then
        begin
            readln(u);access(u);
        end;
        if op=2 then
        begin
            readln(u,v);lc:=lca(u,v);
            writeln(find(1,1,n,dfn[u])+find(1,1,n,dfn[v])-2*find(1,1,n,dfn[lc])+1);
        end;
        if op=3 then
        begin
            readln(u);ll:=dfn[u];rr:=ed[u];
            writeln(ask(1,1,n)+1);
        end;
    end;
    close(input);
end.