HDU 4280 （网络流Dinic算法）

转自：http://www.cnblogs.com/liuxin13/p/4717668.html

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn = 100005;
const int oo = 1e9 + 7;
int x, y, n, m;
int source = oo, sink = -oo;
struct Edge
{
	int v, flow, next;
}edge[maxn<<1];
int head[maxn], tol, layer[maxn];

void init(int n)
{
	tol = 0;
	memset(head, -1, sizeof(head));
}

void addedge(int u, int v,int w)
{
	edge[tol].v = v;
	edge[tol].flow = w;
	edge[tol].next = head[u];
	head[u] = tol++;	
}

bool bfs(int start, int End)
{
	queue<int>Q; Q.push(start);
	memset(layer, 0, sizeof(layer));
	layer[start] = 1;

	while (Q.size())
	{
		int u = Q.front(); Q.pop();

		if (u == End)return true;

		for (int j = head[u]; j != -1; j = edge[j].next)
		{
			int v = edge[j].v;

			if (layer[v] == false && edge[j].flow)
			{
				layer[v] = layer[u] + 1;
				Q.push(v);
			}
		}
	}

	return false;
}
int dfs(int u, int MaxFlow, int End)
{
	if (u == End)return MaxFlow;

	int uflow = 0;

	for (int j = head[u]; j != -1; j = edge[j].next)
	{
		int v = edge[j].v;

		if (layer[v] - 1 == layer[u] && edge[j].flow)
		{
			int flow = min(MaxFlow - uflow, edge[j].flow);
			flow = dfs(v, flow, End);

			edge[j].flow -= flow;
			edge[j ^ 1].flow += flow;

			uflow += flow;

			if (uflow == MaxFlow)
				break;
		}
	}

	if (uflow == 0)///优化防止重搜，不优化会超时
		layer[u] = 0;

	return uflow;
}
int dinic(int start, int End, int N)
{
	int MaxFlow = 0;

	while (bfs(start, End) == true)
		MaxFlow += dfs(start, oo, End);

	return MaxFlow;
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		source = oo, sink = -oo;
		int start = 0, end = 0, i;
		scanf("%d%d", &n, &m);
		init(n);
		for (i = 1; i <= n; i++)
		{
			scanf("%d%d", &x, &y);
			if (source > x)
			{
				source = x;
				start = i;
			}
			if (sink < x)
			{
				sink = x;
				end = i;
			}
		}
		while (m--)
		{
			int u, v, c;
			scanf("%d%d%d", &u, &v, &c);
			addedge(u, v, c);
			addedge(v, u, c);
		}
		printf("%d\n", dinic(start, end,1));
	}
	return 0;
}