HDU 3549 Flow Problem（最大流）

#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
using namespace std;
const int maxv = 20;
const long long INF = 0x3f3f3f;
struct Edge
{
int from, to, cap, flow;
Edge() {}
Edge(int from, int to, int cap, int flow)
{
this->from = from;
this->to = to;
this->cap = cap;
this->flow = flow;
}
};
struct Dinic
{
int n, m, s, t;
vector<Edge> edges;
vector<int> G[maxv];
bool vis[maxv];
int d[maxv];
int cur[maxv];
void AddEdge(int from, int to, int cap)
{
edges.push_back(Edge(from, to, cap, 0));
edges.push_back(Edge(to, from, 0, 0));
m = edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}
bool BFS()
{
memset(vis, 0, sizeof(vis));
queue<int>Q;
Q.push(s);
d[s] = 0;
vis[s] = 1;
while (!Q.empty())
{
int x = Q.front();
Q.pop();
for (int i = 0; i < (int)G[x].size(); i++)
{
Edge& e = edges[G[x][i]];
if (!vis[e.to] && e.cap > e.flow)
{
vis[e.to] = 1;
d[e.to] = d[x] + 1;
Q.push(e.to);
}
}
}
return vis[t];
}
int DFS(int x, int a)
{
if (x == t || a == 0) return a;
int flow = 0, f;
for (int& i = cur[x]; i < (int)G[x].size(); i++)
{
Edge& e = edges[G[x][i]];
if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0)
{
e.flow += f;
edges[G[x][i]^1].flow -= f;
flow += f;
a -= f;
if (a == 0) break;
}
}
return flow;
}
int Maxflow(int s, int t)
{
this -> s = s;
this -> t = t;
int flow = 0;
while (BFS())
{
memset(cur, 0, sizeof(cur));
flow += DFS(s, INF);
}
return flow;
}
};
int main()
{
int n, m, u, v, c, i, t;
scanf("%d", &t);
for (int ii = 1; ii <= t; ii++)
{
Dinic H;
scanf("%d%d", &n, &m);
for(i=1; i<=m; ++i)
{
scanf("%d%d%d", &u, &v, &c);
H.AddEdge(u, v, c);
}
printf("Case %d: %d\n", ii, H.Maxflow(1, n));
}
return 0;
}

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 405;
const int maxm = maxn * maxn;
const int inf = 1000000000;
class Dinic
{
public :
struct Node
{
int u, v, f, next;
} e[maxm];

int head[maxn], p, lev[maxn], cur[maxn];
int que[maxm];
void init()
{
p = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v, int f)
{
e[p].u = u;
e[p].v = v;
e[p].f = f;
e[p].next = head[u];
head[u] = p++;
e[p].u = v;
e[p].v = u;
e[p].f = 0;
e[p].next = head[v];
head[v] = p++;
}
bool bfs(int s, int t)
{
int u, v, qin = 0, qout = 0;
memset(lev, 0, sizeof(lev));
lev[s] = 1;
que[qin++] = s;
while(qout != qin)
{
u = que[qout++];
for(int i = head[u]; i != -1; i = e[i].next)
{
if(e[i].f > 0 && !lev[v = e[i].v])
{
lev[v] = lev[u] + 1, que[qin++] = v;
if(v == t) return 1;
}
}
}
return 0;
}
int dfs(int s, int t)
{
int i, f, qin, u, k;
int flow = 0;
while(bfs(s, t))
{
memcpy(cur, head, sizeof(head));
u = s, qin = 0;
while(1)
{
if(u == t)
{
for(k = 0, f = inf; k < qin; k++)
if(e[que[k]].f < f) f = e[que[i=k]].f;
for(k = 0; k < qin; k++)
e[que[k]].f -= f, e[que[k]^1].f += f;
flow += f, u = e[que[qin = i]].u;
}
for(i = cur[u]; cur[u] != -1; i = cur[u] = e[cur[u]].next)
if(e[i].f > 0 && lev[u] + 1 == lev[e[i].v]) break;
if(cur[u] != -1)
que[qin++] = cur[u], u = e[cur[u]].v;
else
{
if(qin == 0) break;
lev[u] = -1, u = e[que[--qin]].u;
}
}
}
return flow;
}
} H;
int main()
{
int n, m, u, v, c, i, t;
scanf("%d", &t);
for (int ii = 1; ii <= t; ii++)
{
H.init();
scanf("%d%d", &n, &m);
for(i=1; i<=m; ++i)
{
scanf("%d%d%d", &u, &v, &c);
H.add(u, v, c);
}
printf("Case %d: %d\n", ii, H.dfs(1, n));
}
return 0;
}