洛谷P4180 严格次小生成树

题目描述

小 C 最近学了很多最小生成树的算法，Prim 算法、Kruskal 算法、消圈算法等等。正当小 C 洋洋得意之时，小 P 又来泼小 C 冷水了。小 P 说，让小 C 求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说：如果最小生成树选择的边集是 E_MEM​，严格次小生成树选择的边集是 E_SES​，那么需要满足：(value(e)value(e) 表示边 ee 的权值) \sum_{e \in E_M}value(e)<\sum_{e \in E_S}value(e)∑e∈EM​​value(e)<∑e∈ES​​value(e)

这下小 C 蒙了，他找到了你，希望你帮他解决这个问题。

输入格式

第一行包含两个整数 NN 和 MM，表示无向图的点数与边数。

接下来 MM 行，每行 33 个数 x,y,zx,y,z 表示，点 xx 和点 yy 之间有一条边，边的权值为 zz。

输出格式

包含一行，仅一个数，表示严格次小生成树的边权和。

输入输出样例

输入 #1复制

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

输出 #1复制

11

说明/提示

数据中无向图不保证无自环

对于 50\%50% 的数据， N\le 2000N≤2000，M\le 3000M≤3000。

对于 80\%80% 的数据， N\le 5\times 10^4N≤5×104，M\le 10^5M≤105。

对于 100\%100% 的数据， N\le 10^5N≤105，M\le 3\times10^5M≤3×105，边权 \in [0,10^9]∈[0,109]，数据保证必定存在严格次小生成树。

上代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>

using namespace std;
const int N = 1e5 + 10;

#define gc getchar()

int n, m, now = 1;
struct Node {
	int u, v, w, is_in;
	bool operator <(const Node a)const {
		return w < a.w;
	}
} E[N * 3];
struct Node_2{int u, v, w, nxt;} G[(N * 3) << 1];
int fa[N][30], Max[N][30], Tmax[N][30], deep[N], head[N], father[N];
int Mi[30];

#define LL long long
LL Answer; int Min = 1e9;

inline int read() {
	int x = 0; char c = gc;
	while(c < '0' || c > '9') c = gc;
	while(c >= '0' || c >= '9') x = x * 10 + c - '0', c = gc;
	return x;
}

void Add(int u, int v, int w) {G[now].v = v; G[now].w = w; G[now].nxt = head[u]; head[u] = now ++;}
int Getfa(int x) {return father[x] == x ? x : father[x] = Getfa(father[x]);}

void Mst() {
	int js(0);
	for(int i = 1; js != n - 1; i ++) {
		int u = E[i].u, v = E[i].v, fu = Getfa(u), fv = Getfa(v);
		if(fu != fv) {
			father[fu] = fv; 
			js ++; 
			E[i].is_in = 1; 
			Answer += (LL)E[i].w;
			Add(E[i].u, E[i].v, E[i].w);
			Add(E[i].v, E[i].u, E[i].w);
		}
	}
}

void Dfs(int x, int f_, int dep) {
	deep[x] = dep;
	for(int i = 1; ; i ++) {
		if(deep[x] - Mi[i] < 0) break;
		fa[x][i] = fa[fa[x][i - 1]][i - 1];
		Max[x][i] = max(Max[x][i - 1], Max[fa[x][i - 1]][i - 1]);
		if(Max[x][i - 1] == Max[fa[x][i - 1]][i - 1]) 
			Tmax[x][i] = max(Tmax[x][i - 1], Tmax[fa[x][i - 1]][i - 1]);
		else
			Tmax[x][i] = max(min(Max[x][i - 1], Max[fa[x][i - 1]][i - 1]), 
						 max(Tmax[x][i - 1], Tmax[fa[x][i - 1]][i - 1]));
	}
	for(int i = head[x]; ~ i; i = G[i].nxt) {
		int v = G[i].v;
		if(v != f_) {fa[v][0] = x; Max[v][0] = G[i].w; Tmax[v][0] = -1; Dfs(v, x, dep + 1);}
	}
}

int Lca(int x, int y) {
	if(deep[x] < deep[y]) swap(x, y);
	int k = deep[x] - deep[y];
	for(int i = 0; i <=  17; i ++)
		if(k >> i & 1) x = fa[x][i];
	if(x == y) return x;
	for(int i = 17; i >= 0; i --)
		if(fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
	return fa[x][0];
}

void Work(int s, int t, int w_) {
	int m1 = 0, m2 = 0, k = deep[s] - deep[t];
	for(int i = 0; i <= 17; i ++) {
		if(k >> i & 1) {
			m2 = max(m2, Tmax[s][i]);
			if(Max[s][i] > m1) {m2 = max(m2, m1); m1 = Max[s][i];}
		}
	}
	if(m1 == w_) Min = min(Min, w_ - m2);
	else Min = min(Min, w_ - m1);
}

int main() {
	n = read(); m = read();
	for(int i = 1; i <= n; i ++) head[i] = -1, father[i] = i;
	Mi[0] = 1;
	for(int i = 1; i <= 17; i ++) Mi[i] = Mi[i - 1] * 2;
	for(int i = 1; i <= m; i ++) {E[i].u = read(), E[i].v = read(), E[i].w = read();}
	sort(E + 1, E + m + 1);
	Mst();
	Dfs(1, 0, 1);
	for(int i = 1; i <= m; i ++) {
		if(!E[i].is_in) {
			int u = E[i].u, v = E[i].v;
			int L = Lca(u, v);
			Work(u, L, E[i].w);
			Work(v, L, E[i].w);
		}
	}
	cout << Answer + Min;
	return 0;
}