[BZOJ2095][Poi2010]Bridges

[BZOJ2095][Poi2010]Bridges

试题描述

YYD为了减肥，他来到了瘦海，这是一个巨大的海，海中有 \(n\) 个小岛，小岛之间有m座桥连接，两个小岛之间不会有两座桥，并且从一个小岛可以到另外任意一个小岛。现在YYD想骑单车从小岛 \(1\) 出发，骑过每一座桥，到达每一个小岛，然后回到小岛 \(1\)。霸中同学为了让YYD减肥成功，召唤了大风，由于是海上，风变得十分大，经过每一座桥都有不可避免的风阻碍YYD，YYD十分ddt，于是用泡芙贿赂了你，希望你能帮他找出一条承受的最大风力最小的路线。

注意：通过桥为欧拉回路

输入

输入：第一行为两个用空格隔开的整数 \(n（2 \le n \le 1000）\)，\(m(1 \le m \le 2000)\)，接下来读入m行由空格隔开的 \(4\) 个整数 \(a，b（1 \le a,b \le n,a \ne b），c，d(1 \le c,d \le 1000）\)，表示第 \(i+1\) 行第 \(i\) 座桥连接小岛 \(a\) 和 \(b\)，从 \(a\) 到 \(b\) 承受的风力为 \(c\)，从 \(b\) 到 \(a\) 承受的风力为 \(d\)。

输出

输出：如果无法完成减肥计划，则输出 NIE，否则第一行输出承受风力的最大值（要使它最小）

输入示例

4 4
1 2 2 4
2 3 3 4
3 4 4 4
4 1 5 4

输出示例

4

数据规模及约定

见“输入”

题解

这题思路很简单，就是二分后做一个混合图欧拉回路。

主要是强调一下混合图欧拉回路的一些细节。（注意这里是回路，即所有点都得满足\(入度 = 出度\)，至于具体做法上网搜到处是）

• 不可以建立流量为 \(2\) 的边，必须要把 \(\frac{出度 - 入度}{2}\) 作为源点连向点的流量， \(\frac{入度 - 出度}{2}\) 作为点向汇点的流量，然后每条边只有 \(1\) 的流量；否则可能会导致在网络流中在两条边中只流 \(1\) 的现象；然后注意建边时判断一下出度减去入度必须是偶数。

• 这题由于需要二分，要做很多次混合图欧拉回路，每次一定要好好清零。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;
#define rep(i, s, t) for(int i = (s); i <= (t); i++)
#define dwn(i, s, t) for(int i = (s); i >= (t); i--)

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
	return x * f;
}

#define maxn 1010
#define maxm 6010
#define oo 2147483647

struct Edge {
	int from, to, flow;
	Edge() {}
	Edge(int _1, int _2, int _3): from(_1), to(_2), flow(_3) {}
} ;
struct Dinic {
	int n, m, s, t, head[maxn], nxt[maxm];
	Edge es[maxm];
	int vis[maxn], hd, tl, Q[maxn];
	int cur[maxn];
	
	void init() {
		m = 0; memset(head, -1, sizeof(head));
		return ;
	}
	void setn(int _n) {
		n = _n;
		return ;
	}
	
	void AddEdge(int a, int b, int c) {
		es[m] = Edge(a, b, c); nxt[m] = head[a]; head[a] = m++;
		es[m] = Edge(b, a, 0); nxt[m] = head[b]; head[b] = m++;
		return ;
	}
	
	bool BFS() {
		memset(vis, 0, sizeof(vis));
		vis[s] = 1;
		hd = tl = 0; Q[++tl] = s;
		while(hd < tl) {
			int u = Q[++hd];
			for(int i = head[u]; i != -1; i = nxt[i]) {
				Edge& e = es[i];
				if(e.flow && !vis[e.to]) vis[e.to] = vis[u] + 1, Q[++tl] = e.to;
			}
		}
		return vis[t] > 0;
	}
	int DFS(int u, int a) {
		if(u == t || !a) return a;
		int f, flow = 0;
		for(int& i = cur[u]; i != -1; i = nxt[i]) {
			Edge& e = es[i];
			if(vis[e.to] == vis[u] + 1 && (f = DFS(e.to, min(a, e.flow)))) {
				flow += f; a -= f;
				e.flow -= f; es[i^1].flow += f;
				if(!a) return flow;
			}
		}
		return flow;
	}
	int MaxFlow(int _s, int _t) {
		s = _s; t = _t;
		int flow = 0;
		while(BFS()) {
			rep(i, 1, n) cur[i] = head[i];
			flow += DFS(s, oo);
		}
		return flow;
	}
} sol;

#define MAXM 2010

struct Edges {
	int a, b, ab, ba;
	Edges() {}
	Edges(int _1, int _2, int _3, int _4): a(_1), b(_2), ab(_3), ba(_4) {}
} eds[MAXM];

int CntP;
struct Point {
	int id;
	Point(): id(0) {}
	int p() { return id ? id : id = ++CntP; }
} S, T, ns[maxn];

int o_deg[maxn];
bool check(int x, int n, int m) {
	memset(o_deg, 0, sizeof(o_deg));
	sol.init();
	rep(i, 1, m) {
		Edges& e = eds[i];
		if(e.ab > x){ o_deg[e.b]++; o_deg[e.a]--; continue; }
		if(e.ba > x){ o_deg[e.a]++; o_deg[e.b]--; continue; }
		o_deg[e.a]++; o_deg[e.b]--;
		sol.AddEdge(ns[e.a].p(), ns[e.b].p(), 1);
	}
	int sum = 0;
	rep(i, 1, n)
		if(o_deg[i] > 0) {
			if(o_deg[i] & 1) return 0;
			sol.AddEdge(S.p(), ns[i].p(), o_deg[i] >> 1), sum += o_deg[i] >> 1;
		}
		else if(o_deg[i] < 0) {
			if(-o_deg[i] & 1) return 0;
			sol.AddEdge(ns[i].p(), T.p(), -o_deg[i] >> 1);
		}
	sol.setn(CntP);
	int mxf = sol.MaxFlow(S.p(), T.p());
	return mxf == sum;
}

int main() {
	int n = read(), m = read(), l = 0, r = 0;
	rep(i, 1, m) {
		int a = read(), b = read(), c = read(), d = read();
		eds[i] = Edges(a, b, c, d);
		l = max(l, min(c, d));
		r = max(r, max(c, d));
	}
	
	while(l < r) {
		int mid = l + r >> 1;
		if(check(mid, n, m)) r = mid; else l = mid + 1;
	}
	
	if(check(l, n, m)) printf("%d\n", l);
	else puts("NIE");
	
	return 0;
}