bzoj 2324 ZJOI 营救皮卡丘 费用流

题的大概意思就是给定一个无向图，边有权值，现在你有k个人在0点，要求走到n点，且满足

1：人们可以分头行动，可以停在某一点不走了

2：当你走到x时，前x-1个点必须全部走过（不同的人走过也行，即分两路走，其中一路走过1-x-1点

，另一路可以走x点）

3：道路可以多次走，点在满足2的情况下可以多次经过

求所有人走过的总路程最短

这道题历尽挫折。。。

首先我们知道想要走到x点，一定是从前x-1个点走过来，假设我们从y走过来，y<x，那么y走到x一定走的

是可以走的最短路，既然可以走x了，那么前x-1个点一定已经走过了，所以y到x的最短路就是当图只有前x点

时的y到x的最短路，那么我们可以用floyd解决，设d[k,i,j]代表只走前K个点，I到J的最短路，那么循环时，最

外层是k，直接记录d[k,i,j]就行了，因为当循环到K时，只用前K个更新过I到J的最短路，所以I到J只会走前K个点

，这时的d[i,j]就是d[k,i,j]了

那么我们对于这道题拆点，每个点拆成Ai,Bi，添加源S，汇T

规定(a,b,c,d)为连接a到b，容量为c，费用为d的有向边

那么我们先(Ai,Bi,1,0)代表这一个点被经过一次，因为每个点有效经过只有一次，下文具体解释

然后(S，0，k,0)，代表从0开始走，一共可以走k个人

然后(Bi,T,1,0)，代表一个人最终停在点I，就相当于这个流没用了，直接流出

然后我们对于每个点I，肯定会从之前的一个点走过来，这就是开始说的floyd处理的过程了，每个J，0<=j<i连向I

(J,I,1,d[I,J,I])

那么这么建的正确性到现在还没有保证，因为题中要求每个点都要被走过，这里只是连边时费用应用了下这个性质，但是

做费用流的时候是没法保证的（就是可能有的点不会被流过），那么Ai连Bi代表这个点被流过，那么我们规定必须流这个边就行了，

也就是经常说的流量的上下界（上界就是容量），规定Ai到Bi的上下界流量都为1

那么具体怎么做，假设对于点A到B规定上界为U(p)，下界为D(own)，那么我们一定会至少流U的，所以剩下的就是D-U，我们

将这条边的流量设为D-U，可这样流量平衡等式就不满足了，也就是A点应该多流出D的，B应该多流入D的，所以添加新的源点X，

汇点Y，(A,x,D,0),(y,B,D,0),(x,y,INF,0)也就是说我们把规定必须流的从X引走然后又流到Y了，这样就行了

对于下界还有一个二分的做法，内个不会。。。

然后这道题可以不用这么麻烦，可以将Ai到Bi的边的费用设成-INF，那么因为我们是最短路找增广路的，所以一定会走这一条边，

然后就好些很多了

对于这道题，还有另一种建图的方式，也是先拆点

然后没有0这个点

加入X,Y点

(s,Y,1,0)代表从0开始走，(Y,X,K,0)代表最多走K个人，

然后拆的点(Ai,Bi,-inf,0)，(Bi,Aj,1,d[j,i,j])和上一种建图代表的一样，然后我们Y,X起的是0的作用

所以(X,Ai,1,d[i,0,i]])，然后再(Ai,T,1,0)，代表走到I不走了

但是光这样建，如果K比N小的时候只会流K个，有的点流不到（上一种方法用的下界解决的），那么这时

(S,Bi,1,0)代表从0，走的人，之后去哪儿，这样直接求就行了。

还有地方可以优化，就是floyd的时候，不用三维数组存，最外层每循环一次直接连边就行了。

 附两种图的代码

/**************************************************************
    Problem: 2324
    User: BLADEVIL
    Language: Pascal
    Result: Accepted
    Time:320 ms
    Memory:1016 kb
****************************************************************/
 
//By BLADEVIL
var
    n, m, k                     :longint;
    x, y, ss, st                :longint;
    l                           :longint;
    d                           :array[0..200,0..200] of longint;
    a, b, c                     :longint;
    pre, other, len, cost       :array[0..40000] of longint;
    last                        :array[0..500] of longint;
    ans                         :longint;
    dis, father                 :array[0..500] of longint;
    flag                        :array[0..500] of boolean;
    que                         :array[0..500] of longint;
     
function min(a,b:longint):longint;
begin
    if a>b then min:=b else min:=a;
end;
     
procedure connect(a,b,c,d:longint);
begin
    inc(l);
    pre[l]:=last[a];
    last[a]:=l;
    other[l]:=b;
    len[l]:=c;
    cost[l]:=d;
end;
 
function spfa:boolean;
var
    h, t, q, p                  :longint;
    cur                         :longint;
     
begin
    filldword(dis,sizeof(dis) div 4,maxlongint div 10);
    que[1]:=ss; dis[ss]:=0;
    h:=0; t:=1;
    while h<>t do
    begin
        h:=h mod 500+1;
        cur:=que[h];
        flag[cur]:=false;
        q:=last[cur];
        while q<>0 do
        begin
            p:=other[q];
            if len[q]>0 then
            begin
                if dis[p]>dis[cur]+cost[q] then
                begin
                    father[p]:=q;
                    dis[p]:=dis[cur]+cost[q];
                    if not flag[p] then
                    begin
                        t:=t mod 500+1;
                        que[t]:=p;
                        flag[p]:=true;
                    end;
                end;
            end;
            q:=pre[q];
        end;
    end;
    if dis[st]=maxlongint div 10 then exit(false) else exit(true);
end;
 
procedure update;
var
    low                         :longint;
    cur                         :longint;
begin
    low:=maxlongint;
    cur:=st;
    while cur<>ss do
    begin
        low:=min(low,len[father[cur]]);
        cur:=other[father[cur] xor 1];
    end;
    cur:=st;
    while cur<>ss do
    begin
        dec(len[father[cur]],low);
        inc(len[father[cur] xor 1],low);
        if cost[father[cur]]<>-maxlongint div 100000 then
            inc(ans,low*cost[father[cur]]);
        cur:=other[father[cur] xor 1];
    end;
end;
 
procedure init;
var
    i, j                        :longint;
begin
    read(n,m,k);
    x:=2*n+2; y:=x+1; ss:=y+1; st:=ss+1;
    l:=1; 
    connect(ss,0,k,0); connect(0,ss,0,0);
    for i:=1 to n do
    begin
        connect(2*i,2*i+1,1,-maxlongint div 100000); 
        connect(2*i+1,2*i,0,maxlongint div 100000);
        connect(2*i+1,st,1,0); connect(st,2*i+1,0,0);
    end;
    filldword(d,sizeof(d) div 4,maxlongint div 10);
    for i:=0 to n do d[i,i]:=0;
    for i:=1 to m do
    begin
        read(a,b,c);
        if c<d[a,b] then
        begin
            d[a,b]:=c; d[b,a]:=c;
        end;
    end;
    for k:=0 to n do
    begin
        for i:=0 to n do
            for j:=0 to n do
                d[i,j]:=min(d[i,j],d[i,k]+d[k,j]);
        connect(0,2*k,1,d[0,k]); connect(2*k,0,0,-d[0,k]);
        for i:=1 to k-1 do
        begin
            connect(2*i+1,2*k,1,d[i,k]);
            connect(2*k,2*i+1,0,-d[i,k]);
        end;
    end;
end;
     
procedure main;
begin
    while spfa do
        update;
    writeln(ans);
end;
     
begin
    init;
    main;
end.

/**************************************************************
    Problem: 2324
    User: BLADEVIL
    Language: Pascal
    Result: Accepted
    Time:424 ms
    Memory:1016 kb
****************************************************************/

//By BLADEVIL
var
    n, m, k                     :longint;
    x, y, ss, st                :longint;
    l                           :longint;
    d                           :array[0..200,0..200] of longint;
    a, b, c                     :longint;
    pre, other, len, cost       :array[0..40000] of longint;
    last                        :array[0..500] of longint;
    ans                         :longint;
    dis, father                 :array[0..500] of longint;
    flag                        :array[0..500] of boolean;
    que                         :array[0..500] of longint;
     
function min(a,b:longint):longint;
begin
    if a>b then min:=b else min:=a;
end;
     
procedure connect(a,b,c,d:longint);
begin
    inc(l);
    pre[l]:=last[a];
    last[a]:=l;
    other[l]:=b;
    len[l]:=c;
    cost[l]:=d;
end;
 
function spfa:boolean;
var
    h, t, q, p                  :longint;
    cur                         :longint;
     
begin
    filldword(dis,sizeof(dis) div 4,maxlongint div 10);
    que[1]:=ss; dis[ss]:=0;
    h:=0; t:=1;
    while h<>t do
    begin
        h:=h mod 500+1;
        cur:=que[h];
        flag[cur]:=false;
        q:=last[cur];
        while q<>0 do
        begin
            p:=other[q];
            if len[q]>0 then
            begin
                if dis[p]>dis[cur]+cost[q] then
                begin
                    father[p]:=q;
                    dis[p]:=dis[cur]+cost[q];
                    if not flag[p] then
                    begin
                        t:=t mod 500+1;
                        que[t]:=p;
                        flag[p]:=true;
                    end;
                end;
            end;
            q:=pre[q];
        end;
    end;
    if dis[st]=maxlongint div 10 then exit(false) else exit(true);
end;
 
procedure update;
var
    low                         :longint;
    cur                         :longint;
begin
    low:=maxlongint;
    cur:=st;
    while cur<>ss do
    begin
        low:=min(low,len[father[cur]]);
        cur:=other[father[cur] xor 1];
    end;
    cur:=st;
    while cur<>ss do
    begin
        dec(len[father[cur]],low);
        inc(len[father[cur] xor 1],low);
        inc(ans,low*cost[father[cur]]);
        cur:=other[father[cur] xor 1];
    end;
end;
 
procedure init;
var
    i, j                        :longint;
begin
    read(n,m,k);
    x:=2*n+1; y:=x+1; ss:=y+1; st:=ss+1;
    l:=1;
    for i:=1 to n do
    begin
        connect(i,i+n,1,0); connect(i+n,i,0,0);
        connect(i+n,y,1,0); connect(y,i+n,0,0);
        connect(ss,i+n,1,0); connect(i+n,ss,0,0);
        connect(i,st,1,0);  connect(st,i,0,0);
    end;
    connect(y,x,k,0); connect(x,y,0,0);
    filldword(d,sizeof(d) div 4,maxlongint div 4);
    for i:=0 to n do d[i,i]:=0;
    for i:=1 to m do
    begin
        read(a,b,c);
        if c<d[a,b] then
        begin
            d[a,b]:=c; d[b,a]:=c;
        end;
    end;
    for k:=0 to n do
    begin
        for i:=0 to n do
            for j:=0 to n do
                d[i,j]:=min(d[i,j],d[i,k]+d[k,j]);
        connect(x,k,1,d[0,k]); connect(k,x,0,-d[0,k]);
        for i:=1 to k-1 do
        begin
            connect(i+n,k,1,d[i,k]);
            connect(k,i+n,0,-d[i,k]);
        end;
    end;
end;
     
procedure main;
begin
    while spfa do
        update;
    writeln(ans);
end;
     
begin
    init;
    main;
end.