CodeForces 653D Delivery Bears

最大流的过程中会分流，无法保证每个人的流量相同。
所以先变换一下边权，重新建图，二分每个人的初始流量mid，边权为w/mid。
含义是路径最大通过人数，然后判断能否maxflow达到x。

#ifdef _DEBUG
#pragma warning(disable : 4996)
#endif
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <sstream>
#include <utility>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <cctype>
#define CLEAR(a, b) memset(a, b, sizeof(a))
#define CLOSE() ios::sync_with_stdio(false)
#define IN() freopen("in.txt", "r", stdin)
#define OUT() freopen("out.txt", "w", stdout)
#define PF(a) printf("%d\n", a)
#define SF(a) scanf("%d", &a)
#define SFF(a, b) scanf("%d%d", &a, &b)
#define SFFF(a, b, c) scanf("%d%d%d", &a, &b, &c)
#define FOR(i, a, b) for(int i = a; i < b; ++i)
#define LL long long
#define maxn 300005
#define maxm 250005
#define MOD 10000
#define INF 1e18
using namespace std;
//-------------------------CHC------------------------------//
//CodeForces 653D Delivery Bears
//最大流板子
//用#define type xxx替代流的类型(int, double, long long)
//极其关键：边数开两倍
#define type int
int n;
int s, t;
struct Edge {
	int from, to, next;
	type cap, flow;
	void get(int u, int a, int b, type c, type d) {
		from = u; to = a; next = b; cap = c; flow = d;
	}
}edge[maxm];
int tol;
int head[maxn];
int gap[maxn], dep[maxn], pre[maxn], cur[maxn];
void init() {
	tol = 0;
	memset(head, -1, sizeof head);
}

void add_edge(int u, int v, type w, type rw = 0) {
	//cout << u << " " << v << " " << w << endl;
	edge[tol].get(u, v, head[u], w, 0); head[u] = tol++;
	edge[tol].get(v, u, head[v], rw, 0); head[v] = tol++;
}

type sap(int start, int end, int N) {
	memset(gap, 0, sizeof gap);
	memset(dep, 0, sizeof dep);
	memcpy(cur, head, sizeof head);
	int u = start;
	pre[u] = -1;
	gap[0] = N;
	type ans = 0;
	while (dep[start] < N) {
		if (u == end) {
			type Min = INF;
			for (int i = pre[u]; i != -1; i = pre[edge[i ^ 1].to])
				if (Min > edge[i].cap - edge[i].flow)
					Min = edge[i].cap - edge[i].flow;
			for (int i = pre[u]; i != -1; i = pre[edge[i ^ 1].to]) {
				edge[i].flow += Min;
				edge[i ^ 1].flow -= Min;
			}
			u = start;
			ans += Min;
			continue;
		}
		bool flag = false;
		int v;
		for (int i = cur[u]; i != -1; i = edge[i].next) {
			v = edge[i].to;
			if (edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]) {
				flag = true;
				cur[u] = pre[v] = i;
				break;
			}
		}
		if (flag) {
			u = v;
			continue;
		}
		int Min = N;
		for (int i = head[u]; i != -1; i = edge[i].next)
			if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) {
				Min = dep[edge[i].to];
				cur[u] = i;
			}
		gap[dep[u]]--;
		if (!gap[dep[u]]) return ans;
		dep[u] = Min + 1;
		gap[dep[u]]++;
		if (u != start) u = edge[pre[u] ^ 1].to;
	}
	return ans;
}

int u[maxm], v[maxm], w[maxm];
int m, k;

int check(double mid) {
	init();
	FOR(i, 1, m + 1) add_edge(u[i], v[i], (int)min(1.0*w[i] / mid, 1.0*k));
	return sap(1, n, n) >= k;
}

int main() {
	while (SFFF(n, m, k) == 3) {
		FOR(i, 1, m + 1) SFFF(u[i], v[i], w[i]);
		double mid, l = 0, r = 1e9;
		FOR(i, 0, 100) {
			mid = (l + r) / 2;
			if (check(mid)) l = mid;
			else r = mid;
		}
		printf("%.10lf\n", (double)k*l);
	}
	return 0;
}