Solution -「POI 2010」「洛谷 P3511」MOS-Bridges

\(\mathcal{Description}\)

  Link.（洛谷上这翻译真的一言难尽呐。

  给定一个 \(n\) 个点 \(m\) 条边的无向图，一条边 \((u,v,a,b)\) 表示从 \(u\) 到 \(v\) 的代价为 \(a\)，\(v\) 到 \(u\) 的代价为 \(b\)。求从结点 \(1\) 开始的，经过每个点至少一次，每条边恰好一次，最后回到结点 \(1\) 的路径，使得每条边代价的最大值最小。

  \(n,a,b\le10^3\)，\(m\le2\times10^4\)。

\(\mathcal{Solution}\)

  二分嘛，考虑如何 check。

  不妨设每条边 \((u,v,a,b)\) 都有 \(a\le b\)，那么能经过每条边，必然能经过每条 \(\langle u,v\rangle\)。直接如此钦定所有边的方向，现在就是要考虑能够翻转某些边使得边构成有向欧拉回路，即每个点出入度相等。

  记 \(\Delta(u)=\operatorname{ind}(u)-\operatorname{outd}(u)\)，显然一条合法的反向边 \(\langle v,u\rangle\) 替换入路径会使 \(\Delta(u)\leftarrow\Delta(u)+1,\Delta(v)\leftarrow\Delta(v)-1\)，那这就是一个网络流模型：\(S\) 连向 \(u\)（\(\Delta(u)>0\)），流量为 \(\Delta(u)-\frac{\operatorname{deg}(u)}2\)，反向边则体现为 \(v\) 到 \(u\)，流量为 \(1\) 的边，最后 \(v\)（\(\Delta(v)<0\)）连向 \(T\)，流量为 \(\frac{\operatorname{deg}(v)}2-\Delta(v)\)，检查最大流是否为 \(u\) 的总数即可。

  复杂度 \(\mathcal O(D\log\max\{b\})\)，其中 \(D\) 为 Dinic 算法对于此图的复杂度（即我不知道但可过的复杂度）。

\(\mathcal{Code}\)

/* Clearink */

#include <queue>
#include <cstdio>
#include <vector>
#include <assert.h>
#include <algorithm>

inline int rint () {
	int x = 0; char s = getchar ();
	for ( ; s < '0' || '9' < s; s = getchar () );
	for ( ; '0' <= s && s <= '9'; s = getchar () ) x = x * 10 + ( s ^ '0' );
	return x;
}

inline void wint ( const int x ) {
	if ( 9 < x ) wint ( x / 10 );
	putchar ( x % 10 ^ '0' );
}

inline int imin ( const int a, const int b ) { return a < b ? a : b; }

const int MAXN = 10000, MAXM = 2e5, INF = 0x3f3f3f3f;
int n, m, rev[MAXN + 5], deg[MAXN + 5];
bool conn[MAXN + 5]; // some nodes must be connected with 1.
struct Edge { int u, v, a, b; } edge[MAXM + 5];

struct DSU {
	int fa[MAXN + 5];
	inline void clear () { for ( int i = 1; i <= n; ++i ) fa[i] = i; }
	inline int find ( const int x ) { return x ^ fa[x] ? fa[x] = find ( fa[x] ) : x; }
	inline void unite ( int x, int y ) { fa[find ( x )] = find ( y ); }
} dsu;

struct MaxFlowGraph {
	int ecnt, head[MAXN + 5], S, T;
	int curh[MAXN + 5], d[MAXN + 5];
	struct Edge { int to, flow, nxt; } graph[MAXM * 2 + MAXN * 2 + 5];

	inline void clear () {
		ecnt = 1;
		for ( int i = S; i <= T; ++i ) head[i] = 0;
	}

	inline void link ( const int s, const int t, const int f ) {
		graph[++ecnt] = { t, f, head[s] };
		head[s] = ecnt;
	}

	inline void addEdge ( const int s, const int t, const int f ) {
		link ( s, t, f ), link ( t, s, 0 );
	}

	inline bool BFS () {
		static std::queue<int> que;
		for ( int i = S; i <= T; ++i ) d[i] = -1;
		d[S] = 0, que.push ( S );
		while ( !que.empty () ) {
			int u = que.front (); que.pop ();
			for ( int i = head[u], v; i; i = graph[i].nxt ) {
				if ( graph[i].flow && !~d[v = graph[i].to] ) {
					d[v] = d[u] + 1;
					que.push ( v );
				}
			}
		}
		return ~d[T];
	}

	inline int DFS ( const int u, const int iflow ) {
		if ( u == T ) return iflow;
		int ret = 0;
		for ( int& i = curh[u], v; i; i = graph[i].nxt ) {
			if ( graph[i].flow && d[v = graph[i].to] == d[u] + 1 ) {
				int oflow = DFS ( v, imin ( iflow - ret, graph[i].flow ) );
				ret += oflow, graph[i].flow -= oflow, graph[i ^ 1].flow += oflow;
				if ( ret == iflow ) break;
			}
		}
		if ( !ret ) d[u] = -1;
		return ret;
	}

	inline int Dinic () {
		int ret = 0;
		for ( ; BFS (); ret += DFS ( S, INF ) ) {
			for ( int i = S; i <= T; ++i ) curh[i] = head[i];
		}
		return ret;
	}
} mfg;

inline bool check ( const int lim ) {
	mfg.clear ();
	for ( int i = 1; i <= m; ++i ) {
		if ( edge[i].b <= lim ) {
			mfg.addEdge ( edge[i].v, edge[i].u, 1 );
			rev[i] = mfg.ecnt ^ 1; // `addEdge' let ecnt+=2.
		}
	}
	int out = 0;
	for ( int i = 1; i <= n; ++i ) {
		if ( deg[i] > 0 ) out += deg[i] >> 1, mfg.addEdge ( mfg.S, i, deg[i] >> 1 );
		if ( deg[i] < 0 ) mfg.addEdge ( i, mfg.T, -deg[i] >> 1 );
	}
	return mfg.Dinic () == out;
}

struct FinalGraph {
	int ecnt, head[MAXN + 5];
	struct Edge { int to, nxt; } graph[MAXM + 5];

	inline void link ( const int s, const int t ) {
		graph[++ecnt] = { t, head[s] };
		head[s] = ecnt;
	}

	inline void findEC ( const int u, std::vector<int>& res ) {
		for ( int& i = head[u], t; i; ) {
			i = graph[t = i].nxt;
			findEC ( graph[t].to, res );
			res.push_back ( t );
		}
	}
} fg;

inline void print ( const int lim ) {
	assert ( check ( lim ) ); // to get the rest flow.
	for ( int i = 1; i <= m; ++i ) {
		if ( edge[i].b > lim || mfg.graph[rev[i]].flow ) {
			fg.link ( edge[i].u, edge[i].v );
		} else {
			fg.link ( edge[i].v, edge[i].u );
		}
	}
	std::vector<int> ans;
	fg.findEC ( 1, ans );
	assert ( ( int ) ans.size () == m ); // is the graph connected?
	wint ( lim ), putchar ( '\n' );
	for ( int i = ans.size () - 1; ~i; --i ) {
		wint ( ans[i] ), putchar ( i ? ' ' : '\n' );
	}
}

int main () {
	n = rint (), m = rint ();
	mfg.S = 0, mfg.T = n + 1;
	int l = 0, r = 0;
	conn[1] = true, dsu.clear ();
	for ( int i = 1, u, v, a, b; i <= m; ++i ) {
		u = rint (), v = rint (), a = rint (), b = rint ();
		conn[u] = conn[v] = true, dsu.unite ( u, v );
		if ( a > b ) a ^= b ^= a ^= b, u ^= v ^= u ^= v;
		--deg[u], ++deg[v];
		edge[i] = { u, v, a, b };
		l = a > l ? a : l, r = b > r ? b : r;
	}
	for ( int i = 1; i <= n; ++i ) {
		if ( conn[i] && ( deg[i] & 1 || dsu.find ( i ) ^ dsu.find ( 1 ) ) ) {
			return puts ( "NIE" ), 0;
		}
	}
	int t = ++r;
	while ( l < r ) {
		int mid = l + r >> 1;
		if ( check ( mid ) ) r = mid;
		else l = mid + 1;
	}
	if ( l == t ) return puts ( "NIE" ), 0;
	print ( l );
	return 0;
}