【题解】次小生成树/最小度限制生成树

问题描述

给定一张$N$个点$M$条边的无向图，求无向图的严格次小生成树。

设最小生成树的边权之和为$sum$ ，严格次小生成树就是指边权之和大于$sum$的生成树中最小的一个。

引理

先建出一棵最小生成树，满足使用的边都是最小的，剩下的边（称为非树边）一定没有树边优。如果我们加入一条非树边，删除最小生成树中的一条边，次小生成树一定是包括在以这种方法建出的树中的。

证明：
既然次小生成树$S$比某个生成树大，不妨设这个生成树是$T$。$T$一定可以用$S$替换一条边得到（否则说明$S$是$MST$），此时若$T$不是$MST$，则存在比$T$更小的生成树，与$S$是次小生成树矛盾。所以$T$是$MST$。所以$S$由最小生成树$T$加入一条非树边，删除最小生成树中的一条边得来。

得证。

枚举加入的非树边，先加入，由于删除一条边后仍是生成树，所以只能删掉环中任意一条边，删除环中最大边显然最优（这条边一定小于等于新加的边），将每种情况遍历后取最小值，就是次小生成树。特别的，若环中最大边=新加的边，则取次小边。

该部分时间复杂度$O(n^2)$,可以用LCA倍增算法优化到$O(n\ast logn)$

算法流程：

1. kruskal求出MST，将树中的边加入vector
2. 从1节点开始执行BFS，求出深度、最大值、次大值、父节点
3. 加入非树边（x,y,z），求出u=lac(x,y),从x到u,u到y的路径中求最大值、次大值，然后更新ans=min(ans,sum+z-Max)
4. 输出答案ans

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
const int M=3*1e5+5;
struct rec{
    
    
	int x,y,z;
	friend bool operator <(rec a,rec b) {
    
    return a.z<b.z;}
}e[M];

struct edge{
    
    
	int v,w;
};

void read(int &x) {
    
    
	int f=1;x=0;char c=getchar();
	while(c<'0'||c>'9') {
    
    if(c=='-') f=-1;c=getchar();}
	while(c>='0'&&c<='9') {
    
    x=(x<<1)+(x<<3)+(c^48);c=getchar();}
	x*=f;
}

int n,m,t,fa[N];
int f[N][30],d[N],dist[N][30],dis[N][30];
long long ans,sum;
bool used[N];
vector<edge> son[N];
queue<int> q;

int find(int x) {
    
    
	if(fa[x]!=x) fa[x]=find(fa[x]);
	return fa[x];
}

int lca(int x,int y) {
    
    
	if(d[x]>d[y]) swap(x,y);
	for(int i=t;i>=0;i--)
	    if(d[f[y][i]]>=d[x]) y=f[y][i];
	if(x==y) return x;
	for(int i=t;i>=0;i--)
	    if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
	return f[x][0];
}


void kruskal() {
    
    
    sort(e+1,e+m+1);
	for(int i=1;i<=n;i++) fa[i]=i;
	for(int i=1;i<=m;i++) {
    
    
		int x=e[i].x,y=e[i].y,z=e[i].z;
		int u=find(x),v=find(y);
		if(u!=v) {
    
    
			fa[u]=v;
		    sum+=e[i].z;
		    son[x].push_back((edge){
    
    y,z});
		    son[y].push_back((edge){
    
    x,z});
		    used[i]=1;
		}
	}
}

void bfs() {
    
    
	memset(d,0,sizeof(d));
	q.push(1);d[1]=1;
	while(q.size()) {
    
    
		int x=q.front();q.pop();
		for(int i=0;i<son[x].size();i++) {
    
    
			int v=son[x][i].v,w=son[x][i].w;
			if(d[v]) continue;
			d[v]=d[x]+1;
			f[v][0]=x;
			dist[v][0]=w;
			for(int j=1;j<=t;j++) {
    
    
				if((1<<j)>d[v]) break;
				f[v][j]=f[f[v][j-1]][j-1];
				dist[v][j]=max(dist[v][j-1],dist[f[v][j-1]][j-1]);
				if(dist[v][j-1]==dist[f[v][j-1]][j-1]) 
				    dis[v][j]=max(dis[v][j-1],dis[f[v][j-1]][j-1]);
				else if(dist[v][j-1]>dist[f[v][j-1]][j-1])
					dis[v][j]=max(dis[v][j-1],dist[f[v][j-1]][j-1]);
				else if(dist[v][j-1]<dist[f[v][j-1]][j-1])
					dis[v][j]=max(dist[v][j-1],dis[f[v][j-1]][j-1]);
				
			}
			q.push(v);
		}
	}
}

int work(int x,int y,int z) {
    
    
	int fat=lca(x,y);
	
	int dep=d[x]-d[fat];
	int Min=0,Max=0;
	for(int i=0;i<=t;i++) {
    
    
		if((1<<i)>dep) break;
		if(dep&(1<<i)) {
    
    
			dep-=(1<<i);
			if(dist[x][i]>Max) {
    
    
				Min=max(Max,dis[x][i]);
				Max=dist[x][i];
			}
			else Min=max(Min,dist[x][i]);
			x=f[x][i];
		}
	}
	
	dep=d[y]-d[fat];
	for(int i=0;i<=t;i++) {
    
    
		if((1<<i)>dep) break;
		if(dep&(1<<i)) {
    
    
			dep-=(1<<i);
			if(dist[y][i]>Max) {
    
    
				Min=max(Max,dis[y][i]);
				Max=dist[y][i];
			}
			else Min=max(Min,dist[y][i]);
			y=f[y][i];
		}
	}
	if(Max==z) return Min;
	else return Max;
}

int main() {
    
    
	read(n),read(m);
	t=(int)(log(n)/log(2))+1;
	for(int i=1;i<=m;i++) {
    
    
		read(e[i].x),read(e[i].y),read(e[i].z);
	}
	kruskal();
	bfs();
	for(int i=1;i<=m;i++) 
	    if(!used[i]) {
    
    
	    	long long t=e[i].z-work(e[i].x,e[i].y,e[i].z);
	    	if(t==0) continue;
	    	if(!ans||sum+t<ans) ans=sum+t;
		}
	printf("%lld",ans);
}

拓展：野餐规划（最小度限制生成树）

仔细思考一下，本题就好像从第k小生成树反过来求最小生成树，然而真的成立吗？本题n<=30,但是如果n更大，恐怕就要想更强力的贪心了。
https://www.cnblogs.com/gzh-red/p/11032786.html