[BZOJ2324] [ZJOI2011]救助ピカチュウは、チェーンKをカバーする権利のための最小の出発点を与え

#include <ビット/ STDC ++ H>
 使用して 名前空間STDを、
typedefの長い 長いLL。
typedef int型JQK。
名前空間MCMF {
         CONST JQK INF = 0x7f7f7f7f 。
        const  int型 MAXN = 505、MAXM = 130000 ;
        INTヘッド[MAXN]、[MAXM <<に、[MAXN] cur変換1 ]、NXT [MAXM << 1 [MAXM << F]、1 ]、ED = 1 。
        INT S、T、最大パケット、MAXF、[MAXN]事前; 
        JQK LEV [MAXN]、コスト[MAXM << 1];
        BOOL [MAXN]存在します。
        ボイド addedge（INT U、INT V、int型のキャップ、JQKヴァル）{ 
                に[ ++ ED] = V。
                NXT [ED] = ヘッド[U]。
                ヘッド[U] = ED。
                F [ED] = キャップ。
                コスト[編] = valの; 
                [ ++編] = U; 
                NXT [ED] = ヘッド[V]。
                ヘッド[V] = ED。
                F [ED] = 0; 
                コスト[編] = - 1 * ヴァル。
                返します。
        } 
        BOOL spfa（）{
                 int型Uと、
                キュー < 整数 > Q;
                以下のために（int型 iは= 0 ; iが<=最大パケット+ 1 ; iは++ ）{ 
                        存在する[I] = 0 ; 
                        LEV [I] = INF。
                } 
                // memsetの（存在する、偽のsizeof（）が存在します）。
                //memset（LEV、127、はsizeof（LEV））。
                LEV [S] =予備[S] = 0 ; 
                q.push（S）。
                一方、（q.size（））{ 
                        U = q.front（）。
                        q.pop（）; 
                        [U]は存在し = 偽。
                        用（int型 ; I I = I =ヘッド[U] NXT [i]）と
                                 する場合（[I] && LEV [U] +コストF [i]が< LEV [する[I]]）{ 
                                        LEV [iに] = LEV [U] + コスト[i]は、
                                        [I]に】予め =私;
                                        もし（！{[I] [に]存在する）
                                                [I]に]存在 = 真。
                                                （[I]に）q.push。
                                        } 
                                } 
                } 
                のための（int型 I = 0 ; iが最大パケット= + < 1 ; iが++ ）{ 
                        CUR [I] = ヘッド[I]。
                } 
                // のmemcpy（CUR、ヘッド、はsizeof（ヘッド））。
                返す LEVを[T] =！INF。
        }
        JQK増強（）{ 
                JQKデルタ = 0x7f7f7f7f 。
                以下のために（int型 I =プレ[T]を、iは、iは=プレ[する[I ^ 1 ]）
                         であれば（F [i]が< デルタ）{ 
                                デルタ = F [i]は、
                        } 
                のための（int型 ; I iが= [I ^に予備iは[T]を事前= 1 {]）
                        [i]はfを - = デルタ。
                        F [I ^ 1 ] + = デルタ。
                } 
                MAXF+ = デルタ。
                リターン・デルタ* LEV [T]; 
        } 
        ボイドのinit（INT S1、INT T1）{ 
                MAXF = 0 。
                memsetの（ヘッド、0、はsizeof （ヘッド））。
                ED = 1 ; 
                S = S1。
                T = T1。
                返します。
        } 
        JQK MCMF（）{ 
                JQK ANS = 0 。
                のmemset（存在偽、はsizeof （存在））;
                一方、（spfa（））
                         // ANS + = DFS（S、INF）* LEV [T]。
                { 
                        ANS + = 増強（）。
                } 
                戻りANS。
        }は
} 
int型 N、M、K、DIS [ 205 ] [ 205 ]。
INT のmain（）{
         int型、U、V、C。
        scanf関数（" ％D％D％D "、＆​​N、＆M、およびK）; 
        memset（DIS、63、はsizeof （DIS））。
        ために（int型 I = 1 ; I <= M; iが++ ）{ 
                scanf関数（" ％D％D％D "、＆​​U＆V、＆C）を、
                DIS [U] [V] DIS [V] [U] = = 分（DIS [U]を[V]、C）。
        } 
        のための（int型 = K 0 ; kは<= nであり、k ++ ）{
                 ため（int型 I = 0 ; iが<= N; iが++ ）{
                         ため（INT J = 0 ; J <= nであり、j ++ ）{
                                 もし j）は（K <= I || K <=
                                        DIS [I] [J] =分（DIS [I]、[J]、DIS [I] [K] + DIS [K] [J]）。
                        } 
                } 
        } 
        int値S、T。
        S = 2 *（N + 1）+ 2は、T = S + 1 。
        MCMF ::最大パケット = T + 1 ; 
        MCMF ::のinit（s、t）は、
        MCMF :: addedge（S、0、K、0 ）;
        以下のために（int型 i = 1 ; iが<= N; iは++ ）{ 
                （MCMF :: addedgeをS、I、1、 0 ）。
                MCMF :: addedge（iは、N T + 1、0 ）; 
        } 
        のための（int型 I = 0 ; iが<= N; iが++ ）{
                 ため（int型 J = I + 1、J <= nであり、j ++ ）{ 
                        MCMF :: addedge（I、J + N、1 、DIS [I] [J]）。
                } 
        } 
        COUT << MCMF :: MCMF（）。
        リターン 0 ; 
}