hdu 4411 最小费用流

思路：主要就是要把一个每个城市拆为两个点，建一条容量为1，费用为-inf的边，保证每个城市都会被遍历。

/*最小费用最大流*/

#include<iostream>

#include<cstring>

#include<cstring>

#include<cmath>

#include<cstdio>

using namespace std;

const int Maxn = 1010;

const int inf = 1000010;

struct Edge{

    int v;

    int val;

    int cost;

    int next;

}edge[Maxn*100];

int head[Maxn],n,g[Maxn][Maxn],m,k;

int e;

int pre[Maxn], pos[Maxn];

int dis[Maxn], que[Maxn*100];

bool vis[Maxn];

void add(int u, int v, int val, int cost)

{

    edge[e].v = v;

    edge[e].val = val;

    edge[e].cost = cost;

    edge[e].next = head[u];

    head[u] = e++;

    edge[e].v = u;

    edge[e].val = 0;

    edge[e].cost = -cost;

    edge[e].next = head[v];

    head[v] = e++;

}

void init()

{

    memset(head,-1,sizeof(head));

    for(int i=0;i<Maxn;i++)

        for(int j=0;j<Maxn;j++)

        g[i][j]=inf;

    e=0;

}

bool spfa(int s, int t)

{

    int i;

    memset(pre, -1, sizeof(pre));

    memset(vis, 0, sizeof(vis));

    int Head, tail;

    Head = tail = 0;

    for(i = 0; i < Maxn; i++)

        dis[i] = inf;

    que[tail++] = s;

    pre[s] = s;

    dis[s] = 0;

    vis[s] = 1;

    while(Head != tail)

    {

        int now = que[Head++];

        vis[now] = 0;

        for(i=head[now]; i != -1; i = edge[i].next)

        {

            int adj = edge[i].v;

            //cout<<now<<" "<<adj<<" "<<dis[now]<<" "<<edge[i].cost<<" "<<dis[adj]<<" "<<edge[i].val<<endl;

            if(edge[i].val > 0 && dis[now] + edge[i].cost < dis[adj])

            {

                dis[adj] = dis[now] + edge[i].cost;

                pre[adj] = now;

                pos[adj] = i;

                if(!vis[adj])

                {

                    vis[adj] = 1;

                    que[tail++] = adj;

                }

            }

        }

    }

    return pre[t] != -1;

}

int MinCostFlow(int s, int t, int flow)

{

    int i;

    int cost = 0;

    flow = 0;

    while(spfa(s, t))

    {

        int f = inf;

        for(i = t; i != s; i = pre[i])

        if (edge[pos[i]].val < f)

            f = edge[pos[i]].val;

            flow += f;

            cost += dis[t] * f;

            for(i = t; i != s; i = pre[i])

            {

                edge[pos[i]].val -= f;

                edge[pos[i] ^ 1].val += f;

            }

       // cout<<cost<<endl;

    }

    return cost;

    // flow是最大流值

}

void floyd()

{

    int i,j,k;

    for(k=0;k<=n;k++)

        for(i=0;i<=n;i++)

        for(j=0;j<=n;j++)

        {

            if(g[k][j]==inf) continue;

           g[i][j]=min(g[i][j],g[i][k]+g[k][j]);

        }

}

void build(int lim)

{

    memset(head,-1,sizeof(head));

    e=0;

    int ss = 0;

    int s = 2*n+1;

    int t = 2*n+2;

    add(s,ss,lim,0);

    for(int i=1;i<=n;i++)

    {

        if(g[0][i] < inf)

        {

            add(ss,i,1,g[0][i]);

            add(i+n,t,1,g[i][0]);

        }

        add(i,i+n,1,-inf);

        for(int j=i+1;j<=n;j++)

        {

            if(g[i][j] < inf)

            {

            add(i+n,j,1,g[i][j]);

            }

        }

    }

    add(ss,t,k,0);

    return;

}

int solve()

{

    int i,j;

    int ans;

    ans=inf;

    build(k);

    ans=min(ans,MinCostFlow(n+n+1,n+n+2,0)+n*inf);

    return ans;

}

int main()

{

    int i,j,u,v,c;

    while(scanf("%d%d%d",&n,&m,&k)!=EOF,n||m||k)

    {

        init();

        for(i=1;i<=m;i++)

        {

            scanf("%d%d%d",&u,&v,&c);

            if(g[u][v]>c)

            g[u][v]=g[v][u]=c;

        }

        floyd();

        printf("%d\n",solve());

    }

    return 0;

}