bzoj1040 内向树DP

2013-11-17 08:52

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

N个骑士，每个人有一个仇人，那么，每个骑士只有一个后继，将他和他憎恨的人连边，就组成了

一颗内向树，内向树可以看成环儿上挂一堆树，那么我们对于每个环儿上的点，求出以该点为根节点

的子树，取不取该根节点的价值（树P就好了，类似于没有上司的舞会），然后我们得到了一个环儿

知道每个点取不取的价值，求最大价值，那么我们可以破环为链，固定第一个取不取，然后DP，如果

第一个取，那么答案就是c[tot,0]，不取的话答案就是max(c[tot,1],c[tot,0])，tot为环最后一个节点

然后取两个的最大值就好了，因为可能图有多个块，所以累加每个块的最大值就是ans。

Ps：我知道我的代码写的长。。。。风格。。。

//By BLADEVIL
var
    n                           :int64;
    pre, last, other            :array[0..1000010] of int64;
    l                           :int64;
    low, dfn, stack, key        :array[0..1000010] of int64;
    flag                        :array[0..1000010] of boolean;
    time                        :int64;
    que                         :array[0..1000010] of int64;
    fuck                        :int64;
    tot                         :int64;
    v                           :array[0..1000010] of int64;
    w, c                        :array[0..1000010,0..2] of int64;
    finish                      :array[0..1000010] of boolean;
    ans                         :int64;
     
function min(a,b:int64):int64;
begin
    if a>b then min:=b else min:=a;
end;
     
function max(a,b:int64):int64;
begin
    if a>b then max:=a else max:=b;
end;
 
procedure connect(x,y:int64);
begin
    inc(l);
    pre[l]:=last[x];
    last[x]:=l;
    other[l]:=y;
end;
 
procedure init;
var
    i                           :longint;
    y                           :int64;
begin
    read(n);
    for i:=1 to n do
    begin
        read(v[i],y);
        connect(y,i);
    end;
end;
 
procedure dfs(x:int64);
var
    p, q                        :int64;
    cur                         :int64;
begin
    inc(time);
    dfn[x]:=time;
    low[x]:=time;
    inc(tot);
    stack[tot]:=x;
    flag[x]:=true;
 
    q:=last[x];
    while q<>0 do
    begin
        p:=other[q];
        if dfn[p]=0 then
        begin
            dfs(p);
            low[x]:=min(low[x],low[p]);
        end else
        if flag[p] then low[x]:=min(low[x],dfn[p]);
        q:=pre[q];
    end;
     
    cur:=-1;
    if dfn[x]=low[x] then
    begin
        while cur<>x do
        begin
            cur:=stack[tot];
            dec(tot);
            flag[cur]:=false;
            key[cur]:=x;
        end;
    end;
end;
 
procedure doit(x:int64);
var
    q, p                        :int64;
    h, t                        :int64;
    cur                         :int64;
    i                           :longint;
    now                         :int64;
     
begin
    t:=1; h:=0;
    que[1]:=x; q:=last[x];
    while t<>h do
    begin
        inc(h);
        cur:=que[h];
        q:=last[cur];
        while q<>0 do
        begin
            p:=other[q];
            if key[p]=fuck then
            begin
                q:=pre[q];
                continue;
            end;
            inc(t);
            que[t]:=p;
            q:=pre[q];
        end;
    end;
    for i:=t downto 1 do
    begin
        now:=que[i];
        q:=last[now];
        w[now,1]:=v[now];
        if q=0 then w[now,1]:=v[now];
        while q<>0 do
        begin
            p:=other[q];
            if key[p]<>fuck then
            begin
                w[now,0]:=w[now,0]+max(w[p,0],w[p,1]);
                w[now,1]:=w[now,1]+w[p,0];
            end;
            q:=pre[q];
        end;
    end;
end;
 
procedure main;
var
    i, j                        :longint;
    q, p                        :int64;
    f                           :boolean;
    now                         :int64;
     
begin
    for i:=1 to n do if dfn[i]=0 then dfs(i);
    for i:=1 to n do if (low[i]<>dfn[i]) and (not finish[key[i]]) then
    begin
        fuck:=key[i]; finish[fuck]:=true;
        for j:=1 to n do if key[j]=fuck then doit(j);
        fillchar(flag,sizeof(flag),false);
        for j:=1 to n do if key[j]=fuck then break;
        fillchar(que,sizeof(que),0);
        que[1]:=j; tot:=1;
        f:=false;
        while true do
        begin
            q:=last[que[tot]];
            while q<>0 do
            begin
                p:=other[q];
                if flag[p] then
                begin
                    f:=true;
                    break;
                end;
                if key[p]=fuck then
                begin
                    inc(tot);
                    que[tot]:=p;
                    flag[p]:=true;
                end;
                q:=pre[q];
            end;
            if f then break;
        end;
        fillchar(c,sizeof(c),0);
        c[que[1],1]:=-maxlongint; c[que[1],0]:=w[que[1],0];
        for j:=2 to tot-1 do
        begin
            c[que[j],0]:=max(c[que[j-1],0],c[que[j-1],1])+w[que[j],0];
            c[que[j],1]:=c[que[j-1],0]+w[que[j],1];
        end;
        now:=-maxlongint;
        for j:=2 to tot-1 do now:=max(now,max(c[que[j],0],c[que[j],1]));
        fillchar(c,sizeof(c),0);
        c[que[1],1]:=w[que[1],1]; c[que[1],0]:=-maxlongint;
        for j:=2 to tot-1 do
        begin
            c[que[j],0]:=max(c[que[j-1],0],c[que[j-1],1])+w[que[j],0];
            c[que[j],1]:=c[que[j-1],0]+w[que[j],1];
        end;
        for j:=2 to tot-2 do now:=max(now,max(c[que[j],0],c[que[j],1]));
        now:=max(now,c[que[tot-1],0]);
        inc(ans,now);
    end;
    writeln(ans);
end;
 
begin
    init;
    main;
end.