“蔚来杯“2022牛客暑期多校训练营7 L Maximum Range（强连通缩点+网络流输出方案）

"蔚来杯"2022牛客暑期多校训练营7 L Maximum Range（强连通缩点+网络流输出方案）

题意

找一个环 上面的边权 极差最大 并输出 点

思路

我们先强联通缩点 统计出每个强连通分量里的边
难点是在输出方案找环
我们将 源点连向 最大边权的 两个端点 最小边权的 两个端点
我们在跑 最大流的时候记录每条边的 流量 那么 我们最终的答案就是 最大边和最小边 以及有流量的边

代码巨多细节 code挺难的 但偏板子也挺好写的

#include <bits/stdc++.h>
using namespace  std;
//#define  int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define fi first
#define se second
#define pb  push_back
#define inf 1e18
#define de_bug(x) cerr << #x << "=" << x << endl
#define all(a) (a).begin(),(a).end()
#define IOS   std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define  fer(i,a,b)  for(int i=a;i<=b;i++)
#define  der(i,a,b)  for(int i=a;i>=b;i--)
const int mod = 1e9 + 7;
const int N = 1e6 + 10;

const int V = 1e6 + 10;
const int E = 1e6 + 10;
template<typename T>
struct FlowGraph {
	int s, t, vtot;
	int h[V], idx;
	int d[V], cur[V];
	int e[E * 2];
	int ne[E * 2];
	int f[E * 2];
	int  ff[E * 2];
	/*struct edge {
		int v, nxt;
		T f;
	} e[E * 2];
	void addedge(int u,int v, T f){
		e[etot]= {v, head[u], f}; head[u] = etot++;
		e[etot]= {u, head[v], 0}; head[v] = etot++;
	}*/
	void add(int a, int b, int c) {
		e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
		e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx++;
	}
	void add1(int a, int b, int c) {
		e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
		e[idx] = a, f[idx] = c, ne[idx] = h[b], h[b] = idx++;
	}

	bool bfs() {
		for (int i = 1; i <= vtot; i++) {
			d[i] = 0;
			cur[i] = h[i];
		}
		queue<int> q;
		q.push(s);
		d[s] = 1;
		while (!q.empty()) {
			int u = q.front();
			q.pop();
			for (int i = h[u]; ~i; i = ne[i]) {
				int v = e[i];
				if (f[i] && !d[v]) {
					d[v] = d[u] + 1;
					if (v == t) return true;
					q.push(v);
				}
			}
		}
		return false;
	}

	/*	T dfs(int u, T m) {
			if (u == t) return m;
			T flow = 0;
			for (int i = cur[u]; ~i; cur[u] = i = ne[i]){
				int v=e[i];
				if (f[i] && d[v] == d[u] + 1) {
					T t = dfs(v, min(m-flow, f[i]));
					if(!t)d[v]=-1;
					f[i] -= t;
					f[i ^ 1] += t;
					flow+=t;
				}
			}
			return flow;
	    }*/

	T dfs(int u, T m) {
		if (u == t) return m;
		T flow = 0;
		for (int i = cur[u]; ~i; cur[u] = i = ne[i])
			if (f[i] && d[e[i]] == d[u] + 1) {
				T t = dfs(e[i], min(m, f[i]));
				f[i] -= t;
				f[i ^ 1] += t;
				ff[i] += t;
				ff[i ^ 1] -= t;
				m -= t;
				flow += t;
				if (!m) break;
			}
		if (!flow) d[u] = -1;
		return flow;
	}
	T dinic() {
		T flow = 0;
		while (bfs()) flow += dfs(s, numeric_limits<T>::max());
		return flow;
	}
	void init(int s_, int t_, int vtot_) {
		s = s_;
		t = t_;
		vtot = vtot_;
		idx = 0;
		for (int i = 1; i <= vtot; i++) h[i] = -1;
	}
	void dfs1(int u, vector<int>&ans) {
		ans.push_back(u);
		for(int i = h[u]; ~i; i = ne[i]) {
			int v = e[i];
			if(ff[i] > 0) {
				--ff[i];
				dfs1(v, ans);
				break;
			}
		}
	}
};
FlowGraph<int> gg;
int n, m, s, t;
const int M = 1e6 + 100;

pii ve[M];
vector<pii> g[N];
int dfn[N], low[N], idx, cnt;
vector<int>cc[N];
int bridge[M];
int e[M];
int vis[N];
void tarjan(int u, int id) {
	dfn[u] = low[u] = ++idx;
	for ( pii t : g[u]) {
		int  v = t.fi;
		int id2 = t.se;
		if (!dfn[v]) {
			tarjan(v, id2);
			low[u] = min(low[u], low[v]);
			if (dfn[v] == low[v]) bridge[id2] = 1;
		} else if (id != id2) {
			low[u] = min(low[u], dfn[v]);
		}
	}
}
void dfs(int u) {
	vis[u] = 1;
	for(pii t : g[u]) {
		int v = t.fi;
		int id = t.se;
		if(!bridge[id]) {
			cc[cnt].push_back(id);
			if(!vis[v])dfs(v);
		}
	}
}
bool cmp(int x, int y) {
	return e[x] < e[y];
}
void solve() {
	cin >> n >> m;
	fer(i, 1, m) {
		int a, b;
		cin >> a >> b >> e[i];
		g[a].pb({b, i});
		g[b].pb({a, i});
		ve[i] = {a, b};
	}
	tarjan(1, 0);
	fer(i, 1, n) {
		if(!vis[i])++cnt, dfs(i);
	}
	int maa = -1, res = 0;
	fer(i, 1, cnt) {
		sort(all(cc[i]));
		cc[i].erase(unique(all(cc[i])), cc[i].end());
		sort(all(cc[i]), cmp);
		if(cc[i].size() >= 2) {
			int res1 = e[cc[i].back()] - e[*cc[i].begin()];
			if(res1 > maa) {
				maa = res1;
				res = i;
			}
		}
	}
	cout << maa << endl;
	vector<int>ans1;
	vector<int>ans2;
	s = n + 1, t = n + 2;
	int ma = cc[res].back();
	int mi = *cc[res].begin();
	gg.init(s, t, t);
	gg.add(s, ve[ma].fi, 1);
	gg.add(s, ve[ma].se, 1);
	gg.add(ve[mi].fi, t, 1);
	gg.add(ve[mi].se, t, 1);
	for(int x : cc[res]) {
		if(x != ma && x != mi) {
			gg.add1(ve[x].fi, ve[x].se, 1);
		}
	}
	gg.dinic();
	gg.dfs1(s, ans1);
	gg.dfs1(s, ans2);
	cout << ans1.size() + ans2.size() - 4 << endl;
	for(int x : ans1) {
		if(x != s && x != t) cout << x << " ";
	}
	reverse(ans2.begin(), ans2.end());
	for(int x : ans2) {
		if(x != s && x != t) cout << x << " ";
	}
	cout << endl;
}
int main() {
	IOS;
	int _ = 1;
	//cin>>_;
	while( _-- )
		solve();
}