HDU3549 Flow Problem 【最大流量】

Flow Problem

Time Limit: 5000/5000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)

Total Submission(s): 8387 Accepted Submission(s): 3908

[align=left]Problem Description[/align]
Network flow is a well-known difficult problem for ACMers. Given a graph, your task is to find out the maximum flow for the weighted directed graph.

[align=left]Input[/align]
The first line of input contains an integer T, denoting the number of test cases.

For each test case, the first line contains two integers N and M, denoting the number of vertexes and edges in the graph. (2 <= N <= 15, 0 <= M <= 1000)

Next M lines, each line contains three integers X, Y and C, there is an edge from X to Y and the capacity of it is C. (1 <= X, Y <= N, 1 <= C <= 1000)

[align=left]Output[/align]
For each test cases, you should output the maximum flow from source 1 to sink N.

[align=left]Sample Input[/align]

2
3 2
1 2 1
2 3 1
3 3
1 2 1
2 3 1
1 3 1

[align=left]Sample Output[/align]

Case 1: 1
Case 2: 2

[align=left]Author[/align]
HyperHexagon

[align=left]Source[/align]
HyperHexagon's Summer Gift (Original tasks)
水题。

#include <stdio.h>
#include <string.h>

#define maxn 20
#define maxm 2010
#define inf 0x3f3f3f3f

int head[maxn], n, m, source, sink, id; // n个点m条边
struct Node {
int u, v, c, next;
} E[maxm];
int que[maxn], pre[maxn], Layer[maxn];
bool vis[maxn];

void addEdge(int u, int v, int c) {
E[id].u = u; E[id].v = v;
E[id].c = c; E[id].next = head[u];
head[u] = id++;

E[id].u = v; E[id].v = u;
E[id].c = 0; E[id].next = head[v];
head[v] = id++;
}

void getMap() {
int u, v, c; id = 0;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(int) * (n + 1));
source = 1; sink = n;
while(m--) {
scanf("%d%d%d", &u, &v, &c);
addEdge(u, v, c);
}
}

bool countLayer() {
memset(Layer, 0, sizeof(int) * (n + 1));
int id = 0, front = 0, u, v, i;
Layer[source] = 1; que[id++] = source;
while(front != id) {
u = que[front++];
for(i = head[u]; i != -1; i = E[i].next) {
v = E[i].v;
if(E[i].c && !Layer[v]) {
Layer[v] = Layer[u] + 1;
if(v == sink) return true;
else que[id++] = v;
}
}
}
return false;
}

int Dinic() {
int i, u, v, minCut, maxFlow = 0, pos, id = 0;
while(countLayer()) {
memset(vis, 0, sizeof(bool) * (n + 1));
memset(pre, -1, sizeof(int) * (n + 1));
que[id++] = source; vis[source] = 1;
while(id) {
u = que[id - 1];
if(u == sink) {
minCut = inf;
for(i = pre[sink]; i != -1; i = pre[E[i].u])
if(minCut > E[i].c) {
minCut = E[i].c; pos = E[i].u;
}
maxFlow += minCut;
for(i = pre[sink]; i != -1; i = pre[E[i].u]) {
E[i].c -= minCut;
E[i^1].c += minCut;
}
while(que[id-1] != pos)
vis[que[--id]] = 0;
} else {
for(i = head[u]; i != -1; i = E[i].next)
if(E[i].c && Layer[u] + 1 == Layer[v = E[i].v] && !vis[v]) {
vis[v] = 1; que[id++] = v; pre[v] = i; break;
}
if(i == -1) --id;
}
}
}
return maxFlow;
}

void solve(int i) {
printf("Case %d: %d\n", i, Dinic());
}

int main() {
int t, cas;
scanf("%d", &t);
for(cas = 1; cas <= t; ++cas) {
getMap();
solve(cas);
}
}