Codeforce 1100：E. Andrew and Taxi（二分 + 拓扑排序）

题目大意：给你一个 1e5的有向图，你可以把边反向使得图不存在环，设这个操作的花费为所有你反向的边的权值的最大值，询问要消去所有环你的操作的花费最小是多少。

题解：若将图形成环的边全部删掉，剩余的图将是一个DAG，考虑如何把边加回去使得不存在环（这时你可以控制这些边的方向）：对DAG进行拓扑排序，若一条边从拓扑序小的点指向拓扑序大的点，那么一定不会成环：因为你再对这个图进行拓扑排序连通部分的访问顺序不会改变，反之若让拓扑序大的点指向拓扑序小的点，你再对这个图进行拓扑排序时原来拓扑序小的点可能排在拓扑序大的点之后，这可能会导致形成环。

于是产生一个暴力的做法：暴力枚举边权 x，判断只反向边权低于x的边能否得到答案，判断方法就是先删掉这些边再加回来。

答案具有单调性：假设你只反向边权小于 x 的边，若当 $x=x_i$时存在解，那么$x>x_i$时也一定存在解。

于是这题可以二分：

#include<bits/stdc++.h>
using namespace std;
#define lson rt << 1,l,mid
#define rson rt << 1 | 1,mid + 1,r
const int maxn = 1e5 + 10;
int head[maxn],nxt[maxn * 2],to[maxn * 2],w[maxn * 2],cnt;
int x[maxn],y[maxn],z[maxn];
int in[maxn],tot,d[maxn];
int dfn[maxn],del[maxn],num,edg;
int n,m;
void init() {
	cnt = 0;
	fill(head,head + n + 1,-1);
}
void add(int u,int v,int wi) {
	to[cnt] = v;
	nxt[cnt] = head[u];
	w[cnt] = wi;
	head[u] = cnt++;
}
bool tpsort(int x) {
	queue<int> q;
	fill(d,d + n + 1,0);
	fill(dfn,dfn + n + 1,0);
	for(int i = 1; i <= m; i++)
		if(z[i] > x) d[y[i]]++;
	int c = 0;
	for(int i = 1; i <= n; i++)
		if(!d[i]) q.push(i);
	while(!q.empty()) {
		int top = q.front();q.pop();
		dfn[top] = ++c;
		for(int i = head[top]; i + 1; i = nxt[i]) {
			if(w[i] <= x) continue;
			d[to[i]]--;
			if(!d[to[i]]) q.push(to[i]);
		}
	}	
	return c == n;
}
int find() {
	int l = 0,r = 1e9 + 1;
	while(l < r) {
		int mid = l + r >> 1;
		if(tpsort(mid)) r = mid;
		else l = mid + 1;
	}
	return l;
}
int main() {
	scanf("%d%d",&n,&m);	
	init();
	for(int i = 1; i <= m; i++) {
		scanf("%d%d%d",&x[i],&y[i],&z[i]);
		add(x[i],y[i],z[i]);
	}
	int ans = find();
	tpsort(ans);
	int res = 0;
	for(int i = 1; i <= m; i++) {
		if(z[i] > ans) continue;
		if(dfn[x[i]] && dfn[y[i]] && dfn[x[i]] > dfn[y[i]])
			res++;
	}
	printf("%d %d\n",ans,res);
	res = 0;
	for(int i = 1; i <= m; i++) {
		if(z[i] > ans) continue;
		if(dfn[x[i]] && dfn[y[i]] && dfn[x[i]] < dfn[y[i]]) continue;
		if(res) printf(" ");
		printf("%d",i);
		res++;
	}
	cout << endl;
	return 0;
}