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[..] of int64;
    l                           :int64;
    low, dfn, stack, key        :array[..] of int64;
    flag                        :array[..] of boolean;
    time                        :int64;
    que                         :array[..] of int64;
    fuck                        :int64;
    tot                         :int64;
    v                           :array[..] of int64;
    w, c                        :array[..,..] of int64;
    finish                      :array[..] 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:= 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<> do
    begin
        p:=other[q];
        if dfn[p]= 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:=-;
    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:=; h:=;
    que[]:=x; q:=last[x];
    while t<>h do
    begin
        inc(h);
        cur:=que[h];
        q:=last[cur];
        while q<> 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  do
    begin
        now:=que[i];
        q:=last[now];
        w[now,]:=v[now];
        if q= then w[now,]:=v[now];
        while q<> do
        begin
            p:=other[q];
            if key[p]<>fuck then
            begin
                w[now,]:=w[now,]+max(w[p,],w[p,]);
                w[now,]:=w[now,]+w[p,];
            end;
            q:=pre[q];
        end;
    end;
end;

procedure main;
var
    i, j                        :longint;
    q, p                        :int64;
    f                           :boolean;
    now                         :int64;

begin
    for i:= to n do if dfn[i]= then dfs(i);
    for i:= to n do if (low[i]<>dfn[i]) and (not finish[key[i]]) then
    begin
        fuck:=key[i]; finish[fuck]:=true;
        for j:= to n do if key[j]=fuck then doit(j);
        fillchar(flag,sizeof(flag),false);
        for j:= to n do if key[j]=fuck then break;
        fillchar(que,sizeof(que),);
        que[]:=j; tot:=;
        f:=false;
        while true do
        begin
            q:=last[que[tot]];
            while q<> 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),);
        c[que[],]:=-maxlongint; c[que[],]:=w[que[],];
        for j:= to tot- do
        begin
            c[que[j],]:=max(c[que[j-],],c[que[j-],])+w[que[j],];
            c[que[j],]:=c[que[j-],]+w[que[j],];
        end;
        now:=-maxlongint;
        for j:= to tot- do now:=max(now,max(c[que[j],],c[que[j],]));
        fillchar(c,sizeof(c),);
        c[que[],]:=w[que[],]; c[que[],]:=-maxlongint;
        for j:= to tot- do
        begin
            c[que[j],]:=max(c[que[j-],],c[que[j-],])+w[que[j],];
            c[que[j],]:=c[que[j-],]+w[que[j],];
        end;
        for j:= to tot- do now:=max(now,max(c[que[j],],c[que[j],]));
        now:=max(now,c[que[tot-],]);
        inc(ans,now);
    end;
    writeln(ans);
end;

begin
    init;
    main;
end.