ZOJ 3885--The Exchange of Items【最小费用最大流 && 建图】

cheun

　　

The Exchange of Items

Time Limit: 2 Seconds      
Memory Limit: 65536 KB
　　
　　Bob lives in an ancient village, where transactions are done by one item exchange with another. Bob is very clever and he knows what items will become more valuable later on. So, Bob has decided to do some business with villagers.
　　At first, Bob has N kinds of items indexed from 1 to N, and each item hasAi. There are
M ways to exchanges items. For theith way (Xi,
Yi), Bob can exchange oneXith item to one
Yith item, vice versa. Now Bob wants that hisith item has exactly
Bi, and he wonders what the minimal times of transactions is.

Input
　　There are multiple test cases.

For each test case: the first line contains two integers: N and M (1 <=N,
M <= 100).

The next N lines contains two integers: Ai and
Bi (1 <= Ai, Bi <= 10,000).

Following M lines contains two integers: Xi and
Yi (1 <= Xi, Yi <=
N).

There is one empty line between test cases.

Output
　　For each test case output the minimal times of transactions. If Bob could not reach his goal, output -1 instead.

Sample Input

2 1
1 2
2 1
1 2
4 2
1 3
2 1
3 2
2 3
1 2
3 4

Sample Output

1
-1


　　


　　题意：
　　Bob有N种物品，每种物品有Ai个，他想换成Bi个，现在有M种交换方式（一个第i种物品可以换成一个第j种物品，反之亦然，双向的），现在问，Bob达成目标所需的最小交换次数，当不可能完成交换时，输出-1。


　　


　　解析：比较好想的思路。设置一个超级源点，连向所有的物品，容量为Ai，费用为0，设置一个超级汇点，使所有物品连向超级汇点，容量为Bi费用为0，每种交换方式，连接交换双方（双向）容量为INF，费用为1。建完图跑最小费，看最后的最大流会不会等于Bi的和（满流），会的话输出最小费用。
　　

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define maxn 110
#define maxm 110000
#define INF 0x3f3f3f3f
using namespace std;
int n, m;
int inset, outset;
int sum;
struct node {
int u, v, cap, flow, cost, next;
};
node edge[maxm];
int head[maxn], cnt;
int dist[maxn], vis[maxn];
int per[maxn];
void init(){
cnt = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v, int w, int c){
node E1 = {u, v, w, 0, c, head};
edge[cnt] = E1;
head = cnt++;
node E2 = {v, u, 0, 0, -c, head[v]};
edge[cnt] = E2;
head[v] = cnt++;
}
void getmap(){
int a, b;
sum = 0;
outset = 0;
inset = n + 1;
for(int i = 1; i <= n; ++i){
scanf(&quot;%d%d&quot;, &a, &b);
sum += b;
add(outset, i, a, 0);
add(i, inset, b, 0);
}
for(int i = 1; i <= m; ++i){
scanf(&quot;%d%d&quot;, &a, &b);
add(a, b, INF, 1);
add(b, a, INF, 1);
}
}
bool SPFA(int st, int ed){
queue<int>q;
for(int i = 0; i <= inset; ++i){
dist = INF;
vis = 0;
per = -1;
}
dist[st] = 0;
vis[st] = 1;
q.push(st);
while(!q.empty()){
int u = q.front();
q.pop();
vis = 0;
for(int i = head; i != -1; i = edge.next){
node E = edge;
if(dist[E.v] > dist + E.cost && E.cap > E.flow){
dist[E.v] = dist + E.cost;
per[E.v] = i;
if(!vis[E.v]){
vis[E.v] = 1;
q.push(E.v);
}
}
}
}
return per[ed] != -1;
}
void MCMF(int st, int ed, int &cost, int &flow){
flow = 0;
cost = 0;
while(SPFA(st, ed)){
int mins = INF;
for(int i = per[ed]; i != -1; i = per[edge[i ^ 1].v]){
mins = min(mins, edge.cap - edge.flow);
}
for(int i = per[ed]; i != -1; i = per[edge[i ^ 1].v]){
edge.flow += mins;
edge[i ^ 1].flow -= mins;
cost += edge.cost * mins;
}
flow += mins;
}
}
int main (){
while(scanf(&quot;%d%d&quot;, &n, &m) != EOF){
init();
getmap();
int cost ,flow;
MCMF(outset, inset, cost, flow);
if(flow == sum)
printf(&quot;%d\n&quot;, cost);
else
printf(&quot;-1\n&quot;);
}
return 0;
}