HDU 4411 - Arrest(网络流‘最小费用最大流)

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=4411

题意：

起点0有k个人，1~n座城市分别有坏人，k个人分开出动，要按城市顺序捉坏人，所有城市都需要遍历。最后出动的人全部回到起点，求出所有人经过的最短距离。

思路：

题目有几个限定条件：

1.每一个城市都需要经过。

2.按城市顺序捉拿坏人。

按照条件建图。

根据条件一建图：将城市拆点，（i，n+i）费用-inf，容量 1. 相当于强制经过。

根据条件二建图：建边 城市编号小指向编号大的（i+n，j）费用 dis，容量 1。

（源点，0）费用0，容量k，

（0，i）费用dis，容量1.

（0，汇点）费用0，容量k，因为有时不需要k个人全部出动，如果不建此边的话，会造成图一定跑了最大流，而费用非最小了。还有一种处理方法是不建此边，由于费用永远是负的，取费用的最小值。(此种方法原理不明，具体实现详见代码)

AC.

#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cstring>

using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 250;
int n, m, k;
int d[105][105];

void floyd()
{
    for(int k = 0; k <= n; ++k) {
        for(int i = 0; i <= n; ++i) {
            for(int j = 0; j <= n; ++j) {
                d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
            }
        }
    }
}

int tol, head[maxn];
struct Edge{
    int to, next, cap, flow, cost;
}edge[maxn*maxn];

int pre[maxn], dis[maxn], vis[maxn];

void addedge(int u, int v, int cap, int cost)
{
    edge[tol].to = v;  edge[tol].cap = cap; edge[tol].cost = cost; edge[tol].flow = 0;
    edge[tol].next = head[u]; head[u] = tol++;

    edge[tol].to = u;  edge[tol].cap = 0; edge[tol].cost = -cost; edge[tol].flow = 0;
    edge[tol].next = head[v]; head[v] = tol++;
}
void build(int s, int t)
{
    addedge(s, 0, k, 0);
    //addedge(0, t, k, 0);
    for(int i = 1; i <= n; ++i) {
        for(int j = i+1; j <= n; ++j) {
            if(d[i][j] != inf) addedge(n+i, j, 1, d[i][j]);
        }

        addedge(0, i, 1, d[0][i]);
        addedge(i+n, t, 1, d[0][i]);
        addedge(i, i+n, 1, -1000000);

    }
}

int N;
bool spfa(int s, int t)
{
    queue<int> q;
    for(int i = 0; i < N; ++i) {
        dis[i] = inf;
        vis[i] = false;
        pre[i] = -1;
    }
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next) {
            int v = edge[i].to;
            if(edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost) {
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if(!vis[v]) {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t] == -1) return false;
    else return true;
}
int res;
int flow(int s, int t, int &cost)
{
    int flow = 0;
    cost = 0;

    while(spfa(s, t)) {

        int Min = inf;
        for(int i = pre[t]; ~i; i = pre[edge[i^1].to]) {
            if(Min > edge[i].cap - edge[i].flow) {
                Min = edge[i].cap - edge[i].flow;
            }
        }
        for(int i = pre[t]; ~i; i = pre[edge[i^1].to]) {
            edge[i].flow += Min;
            edge[i^1].flow -= Min;
            cost += edge[i].cost * Min;
        }
        res = min(res, cost);
        flow += Min;
     }
     return flow;
}
void init()
{
    tol = 0;
    memset(head, -1, sizeof(head));
}
int main()
{
    //freopen("in", "r", stdin);
    while(~scanf("%d%d%d", &n, &m, &k)) {
        if(n == 0 && m == 0 && k == 0) break;
        for(int i = 0; i <= n; ++i) {
            for(int j = 0; j <= n; ++j) {
                d[i][j] = inf;
                d[i][i] = 0;
            }
        }
        for(int i = 0; i < m; ++i) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            d[u][v] = min(d[u][v], w);
            d[v][u] = min(d[v][u], w);
        }

        floyd();

        init();
        int s = n+n+1, t = n+n+2;
        build(s, t);
        N = n+n+4;
        int cost;
        res = 0;
        flow(s, t, cost);
        printf("%d\n", res+1000000*n);
    }
    return 0;
}