hdu 4411 arrest 最小费用流

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;

const int maxe = ;
const int maxn = ;
const int INF  = 0x3f3f3f3f;

int dist[maxn][maxn];
int N,M,K;
const int Max = ;

struct Edge{
    int u,v,flow,cap,cost;
    int next;
    Edge(int u=,int v=,int flow=,int cap=,int cost=,int next=):
        u(u), v(v), flow(flow), cap(cap), cost(cost), next(next){}
};

struct MCMF{
    Edge edges[maxe];
    int head[maxn],cnt;
    int d[maxn];
    bool inq[maxn];
    int pa[maxn];
    int res[maxn];

    void init(){
        memset(head,-,sizeof(head));
        cnt = ;
    }

    void addedge(int u,int v,int cap,int cost){
        edges[cnt] = Edge(u,v,,cap,cost,head[u]);
        head[u] = cnt++;
        edges[cnt] = Edge(v,u,,,-cost,head[v]);
        head[v] = cnt++;
    }

    bool SPFA(int s,int t,int& flow,int& cost){
        memset(d,0x3f,sizeof(d));
        memset(inq,,sizeof(inq));

        queue<int> Q;
        Q.push(s);
        inq[s] = true;  d[s] = ;
        res[s] = INF;  res[t] = ;

        while(!Q.empty()){
            int u = Q.front();   Q.pop();
            inq[u] = false;

            for(int i=head[u];i!=-;i=edges[i].next){
                Edge&  e = edges[i];
                if(e.cap>e.flow && d[e.v] > d[u] + e.cost){
                    d[e.v] = d[u] + e.cost;
                    pa[e.v] = i;
                    res[e.v] = min(res[u],e.cap-e.flow);
                    if(!inq[e.v]){
                        Q.push(e.v);
                        inq[e.v] = true;
                    }
                }
            }
        }
        if(res[t] == )  return false;
        flow += res[t];
        cost += res[t]*d[t];
        for(int i=t;i!=s;i=edges[pa[i]].u){
            edges[pa[i]].flow   += res[t];
            edges[pa[i]^].flow -= res[t];
        }
        return true;
    }

    int MinCost(int s,int t){
        int flow = ,cost = ;
        while(SPFA(s,t,flow,cost)){}

        return cost;
    }
}solver;

void floyd(){
    for(int k=;k<=N;k++)
        for(int i=;i<=N;i++){
            if(dist[i][k] >= INF) continue;
            for(int j=;j<=N;j++){
                if(dist[k][j] >= INF) continue;
                dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j]);
            }
    }
}

int main()
{
    //freopen("E:\\acm\\input.txt","r",stdin);
    while(scanf("%d %d %d",&N,&M,&K)== && N+M+K){
        memset(dist,0x3f,sizeof(dist));

        for(int i=;i<=N;i++)   dist[i][i] = ;
        for(int i=;i<=M;i++){
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            if(dist[u][v] > w)
                dist[u][v] = dist[v][u] = w;
        }
        floyd();

        solver.init();
        int s = *N+, t = *N+;

        solver.addedge(s,,K,);
        solver.addedge(,t,K,);  //有些警察可以一直待   在警局，不出来

        for(int i=;i<=N;i++){
            solver.addedge(i,i+N,,-Max);
            solver.addedge(,i,,dist[][i]);
            solver.addedge(i+N,t,,dist[i][]);
        }

        //达到最大流的基础必须是所有的点的流都要被访问到。

        for(int i=;i<N;i++)
            for(int j=i+;j<=N;j++){
                solver.addedge(i+N,j,,dist[i][j]);
            }
        printf("%d\n",solver.MinCost(s,t)+Max*N);

    }
}