Arrest HDU 费用流

/*
(转)http://www.cnblogs.com/jianglangcaijin/archive/2012/09/24/2700509.html
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4411
题意：有n+1个城市，编号0到n。其中警察局在0号城市，1到n号城市中每个城市都有一个小偷。现在警察局里有K个
警察。现在让这K个警察去抓小偷（当然抓一个小偷只需要一个警察就行了。。）。
（1）每两个城市之间有距离；
（2）在抓i城市的小偷的时候i-1城市的小偷必须先抓住；
（3）所有警察（也可能用不到K个警察）在抓完小偷后都要返回警察局。
求出所有警察抓小偷所走的路程和。
 
思路：我以前只做过一个人在一个n*n的矩阵中从（1,1）走到（n,n），可以走K次可以得到的最大财富（每个格子有一个财富值）。
比较一下，最大的不同在于这个题目遍历时是有顺序的。。不会啊。。上网搜了一下，发现好多建图的方法。。
第一种方法：将1到n每个点拆点，之间连容量为1费用为-INF的边，这样保证每个点都可以被遍历到，i到j（j>i）连容量INF费用为g[i][j]的边，枚举K，跑费用流。。。为什么要枚举K呢。。因为上面的i到j之间的容量为IFN，所以你在警察局有几个人，最后的最大流就是几（前提是这个人数小于n，当警察局的人数大于n的时候，必然有人会一直呆在警察局）。
 
第二种方法：拆点i和i+n(1<=i<=n)。
（1）i+n到j(i<j)连边容量为1，费用为i到j的最短路（抓完i城市的小偷接着去抓j城市的小偷）；//处理顺序的好方法***********
（2）0到i，容量为1，费用g[0][i]（去抓i城市的小偷）；
（3）i+n到汇点，容量为1，费用为g[0][i]（回到警察局）；
（4）i到i+n,容量为1，费用为负无穷，这样就保证肯定这个城市必备访问到；
（5）源点到0，容量为K，费用为0（有K个警察可用）；
（6）在0和汇点连容量为K费用为0的边(有的人可以一直呆在警察局里。。。)
这个方法比上一个方法好的地方在于不用枚举K了，一遍就搞定。。。

  */


#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=2005;
const int INF=10000005;
const int MOD=9000000;

struct Node
{
    int cap,cost,v,next;
}edge[MOD];

int cnt;
int head[maxn],q[MOD];
bool used[maxn];
int pre[maxn],cur[maxn],dis[maxn];

void add(int s,int t,int cap,int cost)
{
    edge[cnt].cap=cap;
    edge[cnt].cost=cost;
    edge[cnt].next=head[s];
    edge[cnt].v=t;
    head[s]=cnt++;
    edge[cnt].cap=0;
    edge[cnt].cost=-cost;
    edge[cnt].next=head[t];
    edge[cnt].v=s;
    head[t]=cnt++;
}

int min(int a,int b){return (a==-1||b<a)?b:a;}

int SPFA(int s,int t,int n)
{
    int f=-1,r=0;
    int i,v;
    q[r]=s;
    for(i=0;i<n;i++)
         dis[i]=INF;
    dis[s]=0;
    pre[s]=s;
    cur[s]=-1;
    memset(used,false,sizeof(used));
    used[s]=true;
    while(f!=r)
    {
        f++;
        if(f>=MOD)f-=MOD;
        s=q[f];
        used[s]=false;
        for(i=head[s];i!=-1;i=edge[i].next)
        {
            v=edge[i].v;
            if(edge[i].cap>0&&dis[s]+edge[i].cost<dis[v])
            {
                dis[v]=dis[s]+edge[i].cost;
                pre[v]=s;
                cur[v]=i;
                if(!used[v])
                {
                    used[v]=true;
                    r++;
                    if(r>=MOD)r-=MOD;
                    q[r]=v;
                }
            }
        }
    }
    return dis[t];
}

int MinCost(int s,int t,int n)
{
    int ans=0;
    int u,v,cap;
    int cost;
    while(1)
    {
        cost=SPFA(s,t,n);
        if(cost==INF)break;
        u=v=t;
        cap=-1;
        for(u=t;u!=s;u=pre[u])
        {
            cap=min(cap,edge[cur[u]].cap);
        }
	//	printf("cost==%d  cap==%d\n",cost,cap);
        ans+=cost*cap;
        u=v=t;
        for(u=t;u!=s;u=pre[u])
        {
            edge[cur[u]].cap-=cap;
            edge[cur[u]^1].cap+=cap;
        }
    }
    return ans;
}

int g[105][105];

void init(int n){
	for(int i=0;i<=n;i++)
		for(int j=0;j<=n;j++)
			g[i][j]=INF;
	cnt=0;
	memset(head,-1,sizeof(head));
}

void floy(int n){
	for(int k=0;k<=n;k++)
		for(int i=0;i<=n;i++)
			for(int j=0;j<=n;j++)
				if(g[i][j]>g[i][k]+g[k][j])
					g[i][j]=g[i][k]+g[k][j];
}
//很好的建图题
void Gao(int n,int k){
	int i,j;
	int s=2*n+1,t=2*n+2;
	add(s,0,k,0);//派k个警察
	add(0,t,k,0);//有的警察可以停留在原地
	for(i=1;i<=n;i++){
		for(j=i+1;j<=n;j++)
			if(g[i][j]<INF)
			add(i+n,j,INF,g[i][j]);//派去i的警察消灭i的小偷后去j流量为INF
		add(i,i+n,1,-INF);//拆点，保证i的小偷肯定抓了  经典
		for(j=i;j<=n;j++){
			add(0,j,1,g[0][j]);//警察去j
			add(j+n,t,1,g[0][j]);//警察会0
		}	
	}	
}

int main()
{
	int i,j;
	int u,v,c;
    int n,m,k;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF && n+m+k){
		init(n);
		for(i=0;i<m;i++){
			scanf("%d%d%d",&u,&v,&c);
			if(g[u][v]>c){
				g[u][v]=c;
				g[v][u]=c;
			}
		}
		floy(n);
		Gao(n,k);
		int s=2*n+1;
		int t=2*n+2;
		printf("%d\n",MinCost(s,t,n*2+3)+n*INF);
	}
    return 0;
}