有源汇上下界最大流

A - 有源汇有上下界最大流

/*
LibreOJ - 116
给定一个包含 n 个点 m
条边的有向图，每条边都有一个流量下界和流量上界。
给定源点 S和汇点 T，求源点到汇点的最大流。
输入格式
第一行包含四个整数 n,m,S,T。
接下来 m行，每行包含四个整数 a,b,c,d 表示点 a 和 b 之间存在一条有向边，该边的流量下界为 c，流量上界为 d。点编号从 1
到 n。
输出格式输出一个整数表示最大流。
如果无解，则输出 No Solution。
数据范围1≤n≤202,1≤m≤9999,1≤a,b≤n,0≤c≤d≤105

输入样例：

10 15 9 10
9 1 17 18
9 2 12 13
9 3 11 12
1 5 3 4
1 6 6 7
1 7 7 8
2 5 9 10
2 6 2 3
2 7 0 1
3 5 3 4
3 6 1 2
3 7 6 7
5 10 16 17
6 10 10 11
7 10 14 15

输出样例：

43

思路：
1，如果该图存在最大流那么一定存在最低流量的一种可行流（即恰好使图中有S到T的有可行流），我们姑且将这个称为基础流
2，对整个图来说，倘若有可行流那么一定是在基础流上面增加流量
3，对于有源汇有上下界最大流，先用有源汇有上下界可行流的方法，找到一个最小的解，此时这个图上的流量加流量下界，就是基础流
4，然后只需在3的基础流上面跑最大流，即可把流量榨干，得到最大流。
具体代码细节如下
*/

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

using namespace std;
const int N = 210, M = (N + 10000) * 2, INF = 1e8;
int n, m, S, T;
int e[M], f[M], ne[M], h[N], idx;
int q[N], cur[N], d[N], A[N];

void add(int a, int b, int c)
{
	e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
	e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

bool bfs()
{
	int tt = 0, hh = 0;
	memset(d, -1, sizeof d);
	q[0] = S, cur[S] = h[S], d[S] = 0;
	while(hh <= tt)
	{
		int t = q[hh ++];
		for(int i = h[t]; ~i; i = ne[i])
		{
			int ver = e[i];
			if(d[ver] == -1 && f[i])
			{
				d[ver] = d[t] + 1;
				cur[ver] = h[ver]; //等于第一条边
				if(ver == T) return true;
				q[ ++ tt] = ver;
			}
		}
	}
	return false;
}

int find(int u, int limit)
{
	if(u == T) return limit;
	int flow = 0;
	for(int i = cur[u]; ~i && flow < limit; i = ne[i])
	{
		cur[u] = i;
		int ver = e[i];
		if(d[ver] == d[u] + 1 && f[i])
		{
			int t = find(ver, min(f[i], limit - flow));
			if(!t) d[ver] = -1;
			f[i] -= t, f[i ^ 1] += t, flow += t;
		}
	}
	return flow;
}

int dinic()
{
	int r = 0, flow;
	while(bfs()) while(flow = find(S, INF)) r += flow;
	return r;
}

int main()
{
	int s, t;
	cin >> n >> m >> s >> t;
	memset(h, -1, sizeof h);
	S = 0, T = n + 1;
	while(m --)
	{
		int x, y, l, r;
		cin >> x >> y >> l >> r;
		add(x, y, r - l);
		A[x] -= l;//存储节点信息
		A[y] += l;
	}
	int tot = 0;
	for(int i = 1; i <= n; i++)
		if(A[i] > 0) add(S, i, A[i]), tot += A[i];//点与点之间的流入流出不平衡的局面营造出来
		else if(A[i] < 0) add(i, T, -A[i]);
	add(t, s, INF);
	if(dinic() < tot) puts("please go home to sleep");
	else
	{
		int res = f[idx - 1];
		S = s, T = t;
		f[idx - 1] = f[idx - 2] = 0;
		cout << res + dinic() << endl;
	}
	return 0;
}