图论算法（七）最小生成树Kruskal算法与（严格）次小生成树
吐槽：严格次小生成树我调了将近10个小时……（虽然有3个小时的电竞时间
Part 1：最小生成树\(Kruskal\)算法
前言
介于我们之前已经讨论过最小生成树的定义和\(Prim\)算法了，这次我们直奔主题——\(Kruskal\)算法
\(Kruskal\)算法工作方式
还是老样子，我们抛开正确性不谈，只谈算法工作方式和代码实现
\(Kruskal\)的思路非常暴躁：把每个点看成是一个单独的连通块，然后把边按照边权排序，从小到大一条一条加入最小生成树，这样直到有\(n-1\)条边被加入了最小生成树
注意每次加入边的时候，至少有原来不连通的两连通块被联通，这样才能够保证不会形成环
为什么不满足上面的条件就会形成环？
显然易见，如果两个点在加入这条边之前，已经可以相互到达了（成为一个连通块），那么这条边就是多余的，在连接之后会形成重边或者环
每一个连通块都是一个无根树，在树上任意两点之间加一条边，一定会形成一个环，所以为了不形成环，我们不加这条边
让我们举一个生动形象的例子（因为电脑画图实在不方便，这里改成手画了）
比如像上面这张带权无向图：
我们模拟\(Kruskal\)，每个点全都分开，从小到大加入边
重复这个操作一直从小到大的加边，直到完成最小生成树
然后这样我们就得到了这个图的最小生成树（不唯一），它的大小为\(7\)
\(Kruskal\)算法实现方式
在算法中，有一个很重要的步骤，就是维护每一条边连通的两个点是不是处于同一个连通块之内，如果处于同一连通块之内，那么这条边是不能被加入最小生成树的
所以我们需要一种数据结构来维护各个连通块的情况，而并查集就很好的满足了我们的要求
PS：不知道什么是并查集？请戳这里
维护一个有\(n\)个集合（每个集合代表一个点）的并查集，初始时每个集合中只有一个元素（点\(i\)）
\(1、\)对于每次加边之前，查询两个端点\(a,b\)是否在同一集合里，如果不在同一集合里，执行\(2\)，如果在同一集合，那么说明\(a,b\)已经连通了，跳过这条边
\(2、\)把这条边计入最小生成树，然后合并点\(a,b\)所在的集合
\(Code\)
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<algorithm>
#include<set>
#include<map>
#include<utility>
#include<iostream>
#include<list>
#include<ctime>
#include<cmath>
#include<cstdlib>
#include<iomanip>
typedef long long int ll;
inline int read(){
int fh=1,x=0;
char ch=getchar();
while(ch<'0'||ch>'9'){ if(ch=='-') fh=-1;ch=getchar(); }
while('0'<=ch&&ch<='9'){ x=(x<<3)+(x<<1)+ch-'0';ch=getchar(); }
return fh*x;
}
inline int _abs(const int x){ return x>=0?x:-x; }
inline int _max(const int x,const int y){ return x>=y?x:y; }
inline int _min(const int x,const int y){ return x<=y?x:y; }
inline int _gcd(const int x,const int y){ return y?_gcd(y,x%y):x; }
inline int _lcm(const int x,const int y){ return x*y/_gcd(x,y); }
const int maxn=5005;
const int inf=1e9;
int n,m;
struct Edge{
int a,b,w;
Edge(){}
}edge[200005];//建立一个结构体,存边的两个端点和权值
bool operator < (const Edge p,const Edge q){ return p.w<q.w; }
//重载运算符,按照权值从小到大排序
int fa[maxn];
int find(const int x){
if(fa[x]==x) return x;
return fa[x]=find(fa[x]);
}//并查集的查询操作,查询x的集合代表
inline int Kruskal(){
int ans=0;//最小生成树大小
std::sort(edge,edge+m);//排个序
for(int i=1;i<=n;i++)//并查集初始化,每个点都是独立的连通块
fa[i]=i;
for(int i=0;i<m;i++){//把所有边扫一遍
int x=edge[i].a,y=edge[i].b;
if(find(x)==find(y)) continue;//如果属于一个集合，就跳出
fa[find(x)]=y;//合并两个集合
ans+=edge[i].w;//统计最小生成树大小
}
return ans;
}
int main(){
n=read(),m=read();
for(int i=0,x,y,z;i<m;i++){
x=read(),y=read(),z=read();
if(x==y) continue;
edge[i].a=x;
edge[i].b=y;
edge[i].w=z;//建图
}
printf("%d\n",Kruskal());//跑最小生成树
return 0;
}
Part 2：求解（严格）次小生成树
传送门：【模板】严格次小生成树
什么是次小生成树
字面意思来讲，次小生成树就是除了最小生成树之外最小的那棵生成树
那么为什么把“严格”加了个括号呢？因为它并不严格（废话）
如果最小生成树选择的边集是\(E_M\)，严格次小生成树选择的边集是\(E_S\)，那么需要满足：\((value(e)\)表示边\(e\)的权值\()\)
\(\sum_{e \in E_M}value(e)<\sum_{e \in E_S}value(e)\)
显然这个公式它比较恶心，简单来说，就是次小生成树的大小必须严格小于最小生成树的大小
如果我们只是在最小生成树上更换了边，但是总的生成树大小一样，那么求出的就是不严格的次小生成树（因为一张图的最小生成树可以有多个，此时求出了另一个最小生成树）
求严格次小生成树（思路篇）
看到“严格次小生成树”，你的第一反应应该是“这个东西会和最小生成树有关！”
所谓“次小”就是除了最小之外的最小的，那么我们先求出最小的，起码不会对我们的求解起阻碍作用吧
假设你已经顺手使用\(Prim\)或者\(Kruskal\)算法求出了这张图的最小生成树
现在，我们可以把这个图上的所有边简单的分成两类了——第一类是在最小生成树上的边（简称树边），第二类是不在最小生成树上的边（简称非树边）
还是一开始的那个图，最小生成树上的边使用蓝笔标出，我们已知这个最小生成树的大小\(size=7\)
可以贪心的转化问题——求第二小，也就是求一个新的生成树大小\(size'\)在比\(size\)小的前提下最大
因为严格次小生成树和最小生成树一定不是同一棵树，那么我们可以考虑用一些非树边，替换掉同等数量的树边
想到替换时，也许你会遇到这些问题，（以下用三元组\((a,b,c)\)表示连通\(a、b\)两点的边，权值为\(c\)）
1. 替换时，怎么保证求出的是\(2\)小而不是\(3\)小、\(4\)小、\(n\)小呢？
根据上面的贪心思路：替换后使得\(size'-size\)最小，那么\(size'\)就是严格次小生成树
2. 一条非树边可以替换掉哪些树边？
显然不可以胡乱替换，因为需要保证求出的次小生成树还有个树的模样（不能出现环、必须连通）
想到利用树的性质：当我们要向一棵树中加入一条边时，会形成且仅形成一个环，并且这个环包含\(a\rightarrow LCA(a,b)\)和\(b\rightarrow LCA(a,b)\)路径中的所有边
我们先把一条非树边\((a,b,c)\)加进去，在\(a\rightarrow LCA(a,b)\)和\(b\rightarrow LCA(a,b)\)路径中的边中删除一条即可保证树的性质
上面的解释理解不能？请看下面的图，帮助理解：
如图，黑色的是树边，现在要把一条绿色的非树边\((8,6,n)\)加进去，那么图中标红的树边就可以被替换
书面证明
对于一棵树\(T\)其中任意两个节点\(a,b\)都存在且仅存在一条简单路径：\(a\rightarrow LCA(a,b)\rightarrow b\)
现在连接\((a,b)\)，那么上式可以写成这样：\(a\rightarrow LCA(a,b)\rightarrow b\rightarrow a\)，显然构成一个环
PS：另外，因为连接\((a,b)\)之前路径只有一条，所以连接后，形成的环也只有一个
证毕
3. 用几条非树边替换几条树边呢？
在解决这个问题之前，先给出另一个结论：
对于任意一条非树边\((a,b,c)\)，在把它加入最小生成树后形成的环中，每一条树边的权值\(w\leq c\)
解决这个问题，需要用到这个结论，所以我们先来证明一下它
证明
设加入的非树边是\((a,b,c)\),产生环包含树边的集合是\(T\)，\(w_e\)表示\(e\)的边权，最小生成树的大小为\(size\)
反证法：
设\(p:\exists e\in T\)且有\(w_e>c\)
假设\(p\)为真，那么此时断掉树边\(e\)，加入非树边\((a,b,c)\)会使得\(size\)减小
但是\(size\)是我们所求出的最小生成树的大小，它不可能更小了，所以\(p\)为假
那么\(!p:\forall e\in T w_e\leq c\)一定为真
证毕
有了上面的结论还不够，要想继续解决这个问题，我们还得大胆猜想，小心求证
做出假设：替换\(1\)条边最优
证明
还记得我们的贪心思路吗：替换后使得\(size'-size\)最小，那么\(size'\)就是严格次小生成树
我们假设用一条非树边\(e_1\)去替换一条树边，运用上面的结论，我们知道所有与\(e_1\)构成环的边的权值\(w\geq w_{e_1}\)
如果我们做这次替换，\(size'\)的大小就会比\(size\)大\(k=w-w_{e_1}\)
考虑特殊情况，\(k=0\)时，代表着我们把两条权值相等的树边和非树边做了替换
但是这么做对\(size'\)没有任何影响，只对次小生成树的形态有影响，但它长得好不好看我们并不关心，我们只关心\(size'\)而已
因为\(k=0\)时，对\(size'\)没有影响，排除这种情况，现在\(k\)的范围\((k>0)\)
（注意我们以后都不再考虑\(k=0\)的情况了！！！）
显然我们选择\(n\)条边，就会产生多个\(k\)值，此时\(size'\)一定大于只选\(1\)条边的\(size'\)
根据贪心思路，要求\(size'\)最小，显然选\(1\)条边做替换最优
证毕
问题解决，选择\(1\)条边做替换最优（也就是最小生成树和次小生成树中权值不相同的边有且只有\(1\)条）
4. 用哪条非树边替换哪条树边？答案怎么更新？
这两个我们逃不掉得枚举其中一个了，这里显然枚举非树边比较方便(设树边边权为\(w\))
因为我们要求\(size'\)最大的，所以要求\((c-w>0)\)且\((c-w)\)尽量小，因为\(c\)一定，只要使得\(w\)尽量大即可（注意这里根据上面的结论，\(c\geq w\)所以不用担心\(c-w<0\)的情况）
枚举每一个非树边\((a,b,c)\)，找到路径\(a\rightarrow LCA(a,b)\)和\(b\rightarrow LCA(a,b)\)中\(w\)最大的那条边，做替换即可，答案就是\(size'=min(size',size+c-w)\)
注意一下小细节：因为\(w\)有可能等于\(c\)，如果做替换的话，求出的并不是严格次小生成树，所以还需要记录一个次大值\(w'\)，如果\(w=c\)，那么答案\(size'=min(size',size+c-w')\)
啰啰嗦嗦这么多，按照上面的思路，就可以求严格次小生成树了
求严格次小生成树（实现篇）
明确了思路，有没有感到干劲十足呢？（必须得干劲十足啊，笔者可是\(1\)小时写完，\(7\)小时\(debug\)的男人）
这里梳理一下我们要用的算法和数据结构吧：
1. 求最小生成树：并查集，\(Kruskal\)，无脑存边
2. 最近公共祖先\(LCA\)：树上倍增，\(dfs\)预处理，邻接表
3. 区间最大/次大\(RMQ\)：树上\(st\)表
4. 一句提醒：不开\(long\) \(long\)见祖宗
所以得到公式：基础算法+数据结构+简单证明=毒瘤题（这题其实出的挺好的，既没超纲，又有一定难度）
大体框架有了，剩下的都是代码实现的细节了，就都在代码注释里讲解吧
求严格次小生成树（代码篇）
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<algorithm>
#include<set>
#include<map>
#include<utility>
#include<iostream>
#include<list>
#include<ctime>
#include<cmath>
#include<cstdlib>
#include<iomanip>
typedef long long int ll;
inline int read(){
int fh=1,x=0;
char ch=getchar();
while(ch<'0'||ch>'9'){ if(ch=='-') fh=-1;ch=getchar(); }
while('0'<=ch&&ch<='9'){ x=(x<<3)+(x<<1)+ch-'0';ch=getchar(); }
return fh*x;
}
inline int _abs(const int x){ return x>=0?x:-x; }
inline ll _max(const ll x,const ll y){ return x>=y?x:y; }
inline ll _min(const ll x,const ll y){ return x<=y?x:y; }
inline int _gcd(const int x,const int y){ return y?_gcd(y,x%y):x; }
inline int _lcm(const int x,const int y){ return x*y/_gcd(x,y); }
const int maxn=100010;
const ll inf=1e18;//赋个极大值
int n,m;
ll MST,ans=inf;//ans是次小生成树,MST是最小生成树
struct Node{
int to;//到达点
ll cost;//边权
};
std::vector<Node>v[maxn];//邻接表存最小生成树
int dep[maxn];//dep[i]表示第i个点的深度
bool vis[maxn];
ll f[maxn][25];//f[i][j]存节点i的2^j级祖先是谁
ll g1[maxn][25];//g1[i][j]存节点i到他的2^j级祖先路径上最大值
ll g2[maxn][25];//g2[i][j]存节点i到他的2^j级祖先路径上次大值
void dfs(const int x){//因为是树上st和树上倍增，所以可以一起预处理
vis[x]=true;//x号点访问过了
for(int i=0;i<v[x].size();i++){//扫所有出边
int y=v[x][i].to;
if(vis[y]) continue;//儿子不能被访问过
dep[y]=dep[x]+1;//儿子的深度是父亲+1
f[y][0]=x;//儿子y的2^0级祖先是父亲x
g1[y][0]=v[x][i].cost;//y到他的2^0级祖先的最大边长
g2[y][0]=-inf;//y到他的2^0级祖先的次大边长(没有次大边长,故为-inf)
dfs(y);//递归预处理
}
}
inline void prework(){//暴力预处理
for(int i=1;i<=20;i++)//枚举2^1-2^20
for(int j=1;j<=n;j++){//枚举每个点
f[j][i]=f[f[j][i-1]][i-1];//正常的倍增更新
g1[j][i]=_max(g1[j][i-1],g1[f[j][i-1]][i-1]);
g2[j][i]=_max(g2[j][i-1],g2[f[j][i-1]][i-1]);
//以下是求次大的精华了
if(g1[j][i-1]>g1[f[j][i-1]][i-1]) g2[j][i]=_max(g2[j][i],g1[f[j][i-1]][i-1]);
//j的2^i次大值,是j的2^(i-1)和j^2(i-1)的2^(i-1)最大值中的较小的那一个
//特别的,如果这两个相等,那么没有次大值,不更新g2数组
else if(g1[j][i-1]<g1[f[j][i-1]][i-1]) g2[j][i]=_max(g2[j][i],g1[j][i-1]);
}
}
inline void LCA(int x,int y,const ll w){
//非树边连接x,y权值为w
//求LCA时候直接更新答案
ll zui=-inf,ci=-inf;//zui表示最大值,ci表示次大值
if(dep[x]>dep[y]) std::swap(x,y);//保证y比x深
for(int i=20;i>=0;i--)//倍增向上处理y
if(dep[f[y][i]]>=dep[x]){
zui=_max(zui,g1[y][i]);//更新路径最大值
ci=_max(ci,g2[y][i]);//更新路径次大值
y=f[y][i];
}
if(x==y){
if(zui!=w) ans=_min(ans,MST-zui+w);//如果最大值和w不等,用最大值更新
else if(ci!=w&&ci>0) ans=_min(ans,MST-ci+w);//有毒瘤情况,没有次大值,此时也不能用次大值更新
return;
}
for(int i=20;i>=0;i--)
if(f[x][i]!=f[y][i]){
zui=_max(zui,_max(g1[x][i],g1[y][i]));
ci=_max(ci,_max(g2[x][i],g2[y][i]));
x=f[x][i];
y=f[y][i];
}//依旧是普通的更新最大、次大值
zui=_max(zui,_max(g1[x][0],g1[y][0]));//更新最后一步的最大值
//注意下面这两句又凝结了人类智慧精华
//因为次大值有可能出现在最后一步上，所以在更新答案前还要更新一下ci
//如果最后两边的某一边是最大值,ci就只能对另一边取max
if(g1[x][0]!=zui) ci=_max(ci,g1[x][0]);
if(g2[y][0]!=zui) ci=_max(ci,g2[y][0]);
if(zui!=w) ans=_min(ans,MST-zui+w);
else if(ci!=w&&ci>0) ans=_min(ans,MST-ci+w);//依旧特判毒瘤情况
}
struct Edge{
int from,to;//连接from和to两个点
ll cost;//边权
bool is_tree;//记录是不是树边
}edge[maxn*3];
bool operator < (const Edge x,const Edge y){ return x.cost<y.cost; }
//重载运算符,按照边权从大到小排序
int fa[maxn];//并查集数组
inline int find(const int x){
if(fa[x]==x) return x;
else return fa[x]=find(fa[x]);
}//查询包含x的集合的代表元素
inline void Kruskal(){
std::sort(edge,edge+m);//先排序
for(int i=1;i<=n;i++)//初始化并查集
fa[i]=i;
for(int i=0;i<m;i++){
int x=edge[i].from;
int y=edge[i].to;
ll z=edge[i].cost;
int a=find(x),b=find(y);
if(a==b) continue;//如果x和y已经连通,continue掉
fa[find(x)]=y;//合并x,y所在集合
MST+=z;//求最小生成树
edge[i].is_tree=true;//标记为树边
v[x].push_back((Node){y,z});//邻接表记录下树边
v[y].push_back((Node){x,z});
}
}
int main(){
n=read(),m=read();
for(int i=0,x,y;i<m;i++){
ll z;
x=read(),y=read();scanf("%lld",&z);
if(x==y) continue;
edge[i].from=x;
edge[i].to=y;
edge[i].cost=z;
}//读入整个图
Kruskal();//初始化最小生成树
dep[1]=1;//设1号点是根节点，把它变成有根树
dfs(1);//从1开始预处理
prework();//倍增预处理
for(int i=0;i<m;i++)//枚举所有边
if(!edge[i].is_tree)//如果是非树边,那么更新答案
LCA(edge[i].from,edge[i].to,edge[i].cost);
printf("%lld\n",ans);//输出答案,不开long long见祖宗
return 0;//我谔谔终于结束
}
不严格次小生成树
严格的都说了，那就再稍微说一两句不严格次小生成树的求法
刚才那么多的证明，就是为了让这个不严格变成严格，现在我们倒过来看，这个问题就变得小儿科了
整体框架不用变，只是我们不需要处理次大值了，每次更新的时候直接\(ans=min(ans,ans+c-w);\)即可
