BZOJ 1977/洛谷P4180 - 次小生成树 Tree（严格次小生成树）

题目链接 https://www.luogu.org/problemnew/show/P4180

【题意】
小C最近学了很多最小生成树的算法，Prim算法、Kurskal算法、消圈算法等等。正当小C洋洋得意之时，小P又来泼小C冷水了。小P说，让小C求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说：如果最小生成树选择的边集是$E_M$，严格次小生成树选择的边集是$E_S$，那么需要满足：($value(e)$表示边$e$的权值) $\sum_{e \in E_M}value(e) < \sum_{e \in E_S} value(e)$ 这下小 C 蒙了，他找到了你，希望你帮他解决这个问题。

【输入格式】
第一行包含两个整数$N$ 和$M$，表示无向图的点数与边数。 接下来 $M$行，每行 3个数$x ,y, z$ 表示，点 $x$ 和点$y$之间有一条边，边的权值为$z$。数据中无向图无自环； 50% 的数据$N≤2 000 ,M≤3 000$； 80% 的数据$N≤50 000 ,M≤100 000$； 100% 的数据$N≤100 000 ,M≤300 000$ ，边权值非负且不超过 $10^9$ 。

【输出格式】
包含一行，仅一个数，表示严格次小生成树的边权和。(数据保证必定存在严格次小生成树)

【输入样例】
5 6
1 2 1
1 3 2
2 4 3
3 5 4
3 4 3
4 5 6

【输出样例】
11

【思路】
一般求次小生成树的方法是枚举所有不在最小生成树中的边，用它们将最小生成树上的一条边换掉（换掉原来的最小瓶颈路）以后形成一个新的生成树，然后取最小值. 但是这道题要求严格次小，还按照刚才的办法，如果枚举某条不在最小生成树种的边时，这条边的权值和最小生成树上对应最小瓶颈路相等，那么这就不是一组解了. 假设这条边的端点为$u,v$,这时我们就不能换掉最小生成树上$u,v$的最小瓶颈路了，而是要换掉从$u$ 到 $v$ 的路径上次大的那一条边，才能保证换完之后新的生成树严格大于最小生成树. 具体实现还要借助于LCA的倍增思想，假设
$depth[u]$ 表示节点 $u$ 的深度
$parent[u][k]$ 表示节点$u$ 向上走 $2^k$步到达的节点，不存在则为-1
$zuida[u][k]$ 表示节点 $u$ 向上走 $2^k$ 步途径的最大边权值，不存在则为-1
$cida[u][k]$ 表示节点 $u$ 向上走 $2^k$ 步途径的次大边权值，不存在则为-1

下面两个状态转移不难想到
$parent[u][k]=parent[parent[u][k-1]][k-1]$
$zuida[u][k]=max\{ zuida[u][k-1],zuida[parent[u][k-1]][k-1] \}$
次大边权值的状态转移不太好想
$cida[u][k]=max \begin{cases} min\{zuida[u][k-1],zuida[parent[u][k-1]][k-1]\} & \text {(zuida[u][k-1]!=zuida[parent[parent[u][k-1]][k-1])} \\ cida[u][k-1] \\ cida[parent[u][k-1][k-1] \end{cases}$
递推边界就是$k=1$，用一次dfs就可以求出边界时的解，在查询某两个点$u,v$的时候采用倍增思想，先让更深的$u$向上走到和$v$同样的高度，然后$u,v$同时向上走到$LCA(u,v)$，用两个变量记录这一过程中经过的最大边权和次大边权

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll inf=1e15;
const int maxn=100005;
const int maxm=300005; 

struct Edge{
	int from,to;
	ll dist;
	Edge(int f,int t,ll d):from(f),to(t),dist(d){}
	bool operator<(const Edge& e)const{
		return dist<e.dist;
	}
};

int n,m;
int par[maxn];
bool ok[maxm];
vector<Edge> edges0,edges;
vector<int> g[maxn];
int depth[maxn];
int parent[maxn][20];
ll zuida[maxn][20],cida[maxn][20]; 

int findrt(int x){return par[x]==x?x:par[x]=findrt(par[x]);}

void add(int from,int to,ll dist){
	edges.push_back(Edge(from,to,dist));
	int x=edges.size();
	g[from].push_back(x-1); 
}

ll kruscal(){
	memset(ok,0,sizeof(ok));
	sort(edges0.begin(),edges0.end());
	for(int i=0;i<n;++i){
		par[i]=i;
		g[i].clear(); 
	}
	int cnt=0;
	ll ans=0;
	for(int i=0;i<m;++i){
		Edge& e=edges0[i];
		int x=findrt(e.from);
		int y=findrt(e.to);
		if(x!=y){
			ok[i]=true;
			par[x]=y;
			int u=e.from;
			int v=e.to;
			ll d=e.dist;
			ans+=d;
			add(u,v,d);
			add(v,u,d);
			if(++cnt==n-1) break;
		}
	}
	return ans;
}

void dfs(int u,int fa,int dep,ll dist){
	depth[u]=dep;
	parent[u][0]=fa;
	zuida[u][0]=dist;
	cida[u][0]=-1;
	for(int i=0;i<g[u].size();++i){
		Edge& e=edges[g[u][i]];
		int v=e.to;
		if(v!=fa) dfs(v,u,dep+1,e.dist);
	}
}

void init(){
	int log=0;
	while((1<<(log+1))<=n) ++log;
	for(int j=1;j<=log;++j){
		for(int i=0;i<n;++i){
			int a=parent[i][j-1];
			if(a==-1){
				parent[i][j]=-1;
				zuida[i][j]=-1;
				cida[i][j]=-1;
			}
			else{
				parent[i][j]=parent[a][j-1];
				zuida[i][j]=max(zuida[i][j-1],zuida[a][j-1]);
				cida[i][j]=-1;
				if(zuida[i][j-1]!=zuida[a][j-1]) 
					cida[i][j]=min(zuida[i][j-1],zuida[a][j-1]);
				cida[i][j]=max(cida[i][j],cida[i][j-1]);
				cida[i][j]=max(cida[i][j],cida[a][j-1]);
			}
		}
	}
}

ll query(int u,int v,ll d){
	if(depth[u]<depth[v]) swap(u,v);
	int log=0;
	while((1<<(log+1))<=depth[u]) ++log;
	
	ll Max=-1,ciMax=-1;
	for(int k=log;k>=0;--k){
		if((depth[u]-depth[v])>>k&1){
			if(Max!=zuida[u][k])
				ciMax=max(ciMax,min(Max,zuida[u][k]));
			ciMax=max(ciMax,cida[u][k]);
			Max=max(Max,zuida[u][k]);
			u=parent[u][k];
		}
	}
	if(u==v){
		if(Max!=d) return Max;
		if(ciMax!=-1) return ciMax;
		else return -inf;
	}
	
	for(int k=log;k>=0;--k){
		if(parent[u][k]!=-1 && parent[u][k]!=parent[v][k]){
			if(Max!=zuida[u][k])
				ciMax=max(ciMax,min(Max,zuida[u][k]));
			ciMax=max(ciMax,cida[u][k]);
			if(Max!=zuida[v][k])
				ciMax=max(ciMax,min(Max,zuida[v][k]));
			ciMax=max(ciMax,cida[v][k]);
			Max=max(Max,zuida[u][k]);
			Max=max(Max,zuida[v][k]);
			u=parent[u][k];
			v=parent[v][k];
		}
	}
	if(Max!=zuida[u][0])
		ciMax=max(ciMax,min(Max,zuida[u][0]));
	ciMax=max(ciMax,cida[u][0]);
	if(Max!=zuida[v][0])
		ciMax=max(ciMax,min(Max,zuida[v][0]));
	ciMax=max(ciMax,cida[v][0]);
	Max=max(Max,zuida[u][0]);
	Max=max(Max,zuida[v][0]);
	
	if(Max!=d) return Max;
	if(ciMax!=-1) return ciMax;
	else return -inf;
}

int main(){
	while(scanf("%d%d",&n,&m)==2){
		edges0.clear();
		edges.clear();
		for(int i=0;i<m;++i){
			int u,v;
			ll w;
			scanf("%d%d%lld",&u,&v,&w);
			edges0.push_back(Edge(u-1,v-1,w));
		}
		ll mst=kruscal();
		dfs(0,-1,0,0);
		init();
		ll ans=inf;
		for(int i=0;i<m;++i){
			if(!ok[i]){
				Edge& e=edges0[i];
				ans=min(ans,mst-query(e.from,e.to,e.dist)+e.dist);
			}
		}
		printf("%lld\n",ans);
	}
	return 0;
}