2016年青岛区域赛 Coding Contest（费用流）

题意：有n个区域，m条边连接这些区域，这些边是单向的。现在给出每个区域有多少个选手，多少个午餐。有的区域的选手没有午餐，所以他们只能去其他区域找午餐。在给定的单向边上面，有一个流量限制，不能通过超过这个数量的人。而且这些边上面有网线，只有一个人通过不会对网线有影响，但是有多于1的数量的人通过的时候，多出来的人通过这条边会有p几率毁坏这条网线。问选手怎样就餐使得毁坏网络的可能性最小。

解法：题意十分明了，一看就是网络流。我们先在选手数目和午餐数目不相等的区域和源点或者汇点建立一条边。

在此之前我们还要解决一个问题，我们知道的p是毁坏的几率，那么（1-p）就是不会毁坏的几率，以（1-p）为费用建图，所有照成影响的选手的几率乘起来就是完全不会有毁坏的几率，假设为q，那么最终答案就是1-q。但是乘法的话有一个问题，我们在使用费用流去每次改变答案的时候我们是乘以概率的流量次方，用while太慢，老是用pow精度丢失太多，都不是个很好的办法。所以我们对每个概率取对数10，这样我们就是化乘法为加法了，最后我们再用一次pow变回来就好了。

所以如果选手数目小于午餐数目，则从此点连一条边到汇点。反之连一条边到源点。

然后还要处理一个人是不会对网线有影响的条件，所以我们要拆边，每条边都拆成一条流量为1，费用为0的边和一条流量为f-1，费用为log10（1-p）的边。

跑一边费用流即可。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 400 + 5;
const int maxm = 50000 + 5;
const long double eps = 1e-6;
int n, m;
int head[maxn], to[maxm], front[maxm], flow[maxm], ppp;
long double cost[maxm];
long double dis[maxn];
int minflow[maxn];
bool flag[maxn];
int par[maxn], par_line[maxn];

struct MIN_COST_MAX_FLOW{
	
	void init() {
		memset(head, -1, sizeof(head));
		ppp = 0;
	}
	
	bool spfa(int s, int t)
	{
		int u, v;
		fill(dis, dis + t + 1, INF);
		memset(flag, 0, sizeof(flag));
		dis[s] = 0;
		minflow[s] = INF;
		queue <int> q;
		q.push(s);
		while(!q.empty())
		{
			u = q.front();
			q.pop();
			flag[u] = 0;
			for(int i = head[u]; ~i; i = front[i])
			{
				v = to[i];
				if(flow[i] > 0 && dis[v] - (dis[u] + cost[i]) > eps)
				{
					dis[v] = dis[u] + cost[i];
					par[v] = u;
					par_line[v] = i;
					minflow[v] = min(minflow[u], flow[i]);
					if(!flag[v])
					{
						flag[v] = 1;
						q.push(v);
					}
				}
			}
		}
		if(abs(dis[t] - INF) < eps)
			return 0;
		return 1;
	}
	
	double slove(int s, int t)
	{
		double ans = 0.0;
		int p;
		while(spfa(s, t))
		{
			p = t;
			while(p != s)
			{
				flow[par_line[p]] -= minflow[t];
				flow[par_line[p]^1] += minflow[t];
				p = par[p];
			}
			ans += dis[t] * minflow[t];
		}
		return ans;
	}
	
	void add_edge(int u, int v, int f, long double c)
	{
		to[ppp] = v, front[ppp] = head[u], flow[ppp] = f, cost[ppp] = c, head[u] = ppp++;
		to[ppp] = u, front[ppp] = head[v], flow[ppp] = 0, cost[ppp] = -c, head[v] = ppp++;
	}
}mcmf;

int main()
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int T;
	cin >> T;
	while(T--) {
		mcmf.init();
		scanf("%d%d", &n, &m);
		int s = n + 1, t = s + 1;
		for(int i = 1; i <= n; i++) {
			int si, bi;
			scanf("%d%d", &si, &bi);
			si -= bi;
			if(si > 0) {
				mcmf.add_edge(s, i, si, 0);
			} else if(si < 0) {
				mcmf.add_edge(i, t, -si, 0);
			}
		}
		int u, v, f;
		double c;
		while(m--)
		{
			scanf("%d%d%d%lf", &u, &v, &f, &c);
			if(f)
				mcmf.add_edge(u, v, 1, 0);
			if(f > 1)  
				mcmf.add_edge(u, v, f - 1, -log10(1.0 - c));
		}
		double ans = -mcmf.slove(s, t);
		printf("%.2f\n", 1.0 - pow(10.0, ans));
	}
	return 0;
}