LA 5095 Transportation 费用流（拆边问题）

LA 5095 Transportation

题目大意：

某国有n（n<=100）座城市，由m（m<=5000）条单向道路相连。你希望从城市1运送k（0<=k<=100）单位货物到城市n。这些道路并不安全，有很多强盗，所以你决定雇保镖来保护你。每条道路都有一个危险系数ai（0<ai<=100），如果你带着x个单位货物通过，需要给保镖aix^2元钱才能保证你的安全（这是合理的，因为带在身边的货物越多越不安全）。另外，每条路上还有一个容量限制Ci（Ci<=5），表示最多只能带Ci个单位的货物通过。注意，货物不能拆开，因此在通过每条边时，身上的货物数量必须是整数。

题目分析：

拆边。对于一个费用系数为a，容量为5的边被拆成5条容量为1，费用各异的弧，费用依次为1a，3a，5a，7a，9a。因为求的是最小费用流，如果这条弧的流量为1，走的肯定是1a；如果流量为2，走的肯定是1a，3a这两条，如果流量为3，走的肯定是1a，3a，5a……不难验证，不管流量是1~5之间的哪一个，相应流量选取的边的费用之和恰好就是未拆边时的相应费用。这样问题就转化成普通的最小费用最大流问题了。

本题是指定固定流量的最小费用问题。但是一个难点是，代价不是固定的，而是和流量的平方成正比。可以进行如下的等效转换：设u,v之间的费用的系数为a,最大容量为c,那么可以在u,v之间添加c条边，每条边的容量都是1，费用分别为1*a,3*a,5*a,..(2c-1)*a。这样既可转化为普通的费用流问题。为什么可以这么做呢？因为每个容量都可以用这c条边组合出来。从数学方面解释是因为利用了恒等式1+3+5+...+(2c-1)=c^2。

所以代码就是除了拆边（存边）的地方改动一下，其余地方套模板。

代码：

#include <stdio.h>  
#include <string.h>  
#include <algorithm>  
#define clear(A, X) memset(A, X, sizeof A)  
#define min(A, B) ((A) < (B) ? (A) : (B))  
using namespace std;  
  
const int maxE = 2000000;  
const int maxN = 256;  
const int oo = 0x3f3f3f3f;  
  
struct Edge{  
    int v, c, w, n;  
    Edge(){}  
    Edge(int V, int C, int W, int N) : v(V), c(C), w(W), n(N){}  
};  
  
struct Node{  
    int l, r, w;  
};  
  
Edge edge[maxE];  
Node sche[maxN];  
int adj[maxN], cntE;  
int Q[maxE], head, tail;  
int d[maxN], inq[maxN], cur[maxN], f[maxN];  
int cost, flow, s, t;  
int N, M, K;  
  
void addedge(int u, int v, int c, int w){  
    edge[cntE] = Edge(v, c,  w, adj[u]); adj[u] = cntE++;  
    edge[cntE] = Edge(u, 0, -w, adj[v]); adj[v] = cntE++;  
}  
  
int spfa(){  
    f[s] = oo;  
    clear(d, oo);  
    clear(inq, 0);  
    cur[s] = -1;  
    d[s] = 0;  
    head = tail = 0;  
    Q[tail++] = s;  
    inq[s] = 1;  
    while(head != tail){  
        int u = Q[head++];  
        inq[u] = 0;  
        for(int i = adj[u]; ~i; i = edge[i].n){  
            int v = edge[i].v, c = edge[i].c, w = edge[i].w;  
            if(c && d[v] > d[u] + w){  
                d[v] = d[u] + w;  
                f[v] = min(f[u], c);  
                cur[v] = i;  
                if(!inq[v]){  
                    Q[tail++] = v;  
                    inq[v] = 1;  
                }  
            }  
        }  
    }  
    if(d[t] == oo) return 0;  
    flow += f[t];  
    cost += d[t] * f[t];  
    for(int i = cur[t]; ~i; i = cur[edge[i ^ 1].v]){  
        edge[i].c -= f[t];  
        edge[i ^ 1].c += f[t];  
    }  
    return 1;  
}  
  
int MCMF(){  
    flow = cost = 0;  
    while(spfa());  
    return cost;  
}  
  
void init(){  
    clear(adj, -1);  
    cntE = 0;  
}  
  
void build(){  
    int u, v, ci, ai;  
    s = 0; t = N;  
    addedge(s, 1, K, 0);  
    for(int i = 1; i <= M; ++i){  
        scanf("%d%d%d%d", &u, &v, &ai, &ci);  
        for(int j = 1; j <= ci; ++j) addedge(u, v, 1, ai * (j * 2 - 1));  
    }  
}  
  
void work(){  
    init();  
    build();  
    MCMF();  
    printf("%d\n", flow == K ? cost : -1);  
}  
  
int main(){  
    while(~scanf("%d%d%d", &N, &M, &K)) work();  
    return 0;  
}