最小生成树,次小生成树

最新推荐文章于 2022-02-19 22:33:39 发布
最新推荐文章于 2022-02-19 22:33:39 发布
阅读量309 收藏
点赞数
分类专栏： C++ 文章标签： C++ 算法 最小生成树 次小生成树 倍增
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuzhuoranf22/article/details/52269887
版权

最小生成树-Prim算法和Kruskal算法

 

Prim算法

1.概览

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英语：Robert C. Prim）独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。

 

2.算法简单描述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空；

3).重复下列操作，直到Vnew = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；

4).输出：使用集合Vnew和Enew来描述所得到的最小生成树。

 

3.简单证明prim算法

反证法：假设prim生成的不是最小生成树

1).设prim生成的树为G0

2).假设存在Gmin使得cost(Gmin)<cost(G0)   则在Gmin中存在<u,v>不属于G0

3).将<u,v>加入G0中可得一个环，且<u,v>不是该环的最长边(这是因为<u,v>∈Gmin)

4).这与prim每次生成最短边矛盾

5).故假设不成立，命题得证.

 

 4.代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=1005;
int m[maxn][maxn];
int d[maxn];
bool visit[maxn];
int n;
int prim(){
int i,j,minn,sum=0,pos;
memset(visit,0,sizeof(visit));
visit[1]=true;pos=1;
for(i=1;i<=n;i++)
if(i!=pos)d[i]=m[pos][i];
for(i=1;i<n;i++){
minn=100000000;
for(j=1;j<=n;j++){
if(!visit[j]&&minn>d[j]){
minn=d[j];pos=j;
}
}
visit[pos]=true;
sum+=minn;
for(j=1;j<=n;j++)
if(!visit[j]&&d[j]>m[pos][j])
d[j]=m[pos][j];
}
return sum;
}
void init(){
int i,j;
scanf("%d",&n);
memset(m,0x3f,sizeof(m));
for(i=1;i<=n;i++)
  for(j=1;j<=n;j++)
     scanf("%d",&m[i][j]);
}
int main(){
init();
printf("%d",prim());
return 0;
}

5.时间复杂度

这里记顶点数v，边数e

邻接矩阵:O(v2)                邻接表:O(elog2v)

 

 

 

Kruskal算法

 

1.概览

Kruskal算法是一种用来寻找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪婪算法的应用。和Boruvka算法不同的地方是，Kruskal算法在图中存在相同权值的边时也有效。

 

2.算法简单描述

1).记Graph中有v个顶点，e个边

2).新建图Graphnew，Graphnew中拥有原图中相同的e个顶点，但没有边

3).将原图Graph中所有e个边按权值从小到大排序

4).循环：从权值最小的边开始遍历每条边 直至图Graph中所有的节点都在同一个连通分量中

               if 这条边连接的两个节点于图Graphnew中不在同一个连通分量中

                                        添加这条边到图Graphnew中

 

3.简单证明Kruskal算法

对图的顶点数n做归纳，证明Kruskal算法对任意n阶图适用。

归纳基础：

n=1，显然能够找到最小生成树。

归纳过程：

假设Kruskal算法对n≤k阶图适用，那么，在k+1阶图G中，我们把最短边的两个端点a和b做一个合并操作，即把u与v合为一个点v'，把原来接在u和v的边都接到v'上去，这样就能够得到一个k阶图G'(u,v的合并是k+1少一条边)，G'最小生成树T'可以用Kruskal算法得到。

我们证明T'+{<u,v>}是G的最小生成树。

用反证法，如果T'+{<u,v>}不是最小生成树，最小生成树是T，即W(T)<W(T'+{<u,v>})。显然T应该包含<u,v>，否则，可以用<u,v>加入到T中，形成一个环，删除环上原有的任意一条边，形成一棵更小权值的生成树。而T-{<u,v>}，是G'的生成树。所以W(T-{<u,v>})<=W(T')，也就是W(T)<=W(T')+W(<u,v>)=W(T'+{<u,v>})，产生了矛盾。于是假设不成立，T'+{<u,v>}是G的最小生成树，Kruskal算法对k+1阶图也适用。

由数学归纳法，Kruskal算法得证。

 

 

 

4.代码算法实现

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int maxn=405;
int n,tot;
bool G[maxn][maxn];
int w[maxn],fa[maxn];
struct node{
int u,v,w;
}e[maxn*maxn];
bool cmp(node a,node b){return a.w<b.w;}


int find(int x){//并查集
if(fa[x]==x)return x;
else return fa[x]=find(fa[x]);
}


int main(){
int i,j,p,ans=0;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&w[i]);
fa[i]=i;
}
for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
scanf("%d",&p);
if(i!=j&&p!=0){
e[++tot].u=i;e[tot].v=j;e[tot].w=p;//用边集数组存边
}
}
}
sort(e+1,e+1+tot,cmp);
for(i=1;i<=tot;i++){
int x=find(e[i].u);
int y=find(e[i].v);
if(x!=y){//当两个点不属于一个并查集，就加入边集中
fa[x]=y;
ans+=e[i].w;
}
}
printf("%d",ans);
return 0;
}

时间复杂度：elog 2e  e为图中的边数

 

 次小生成树：

   我一般写次小生成树是用两种方法：

    1.用Prim先求最小生成树，在求最小生成树时记录每两点之间的最大值（顶点数，边数较小）

     求次小生成树的过程就是每次给原先的最小生成树加边，因为最小生成树已经是联通图，所以每次加边必然会形成环，只要删去环上的最大边，就会得到新的生成树，每次统计，更新答案即可

代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int inf=1000000000;
const int maxn=1005;
int m[maxn][maxn],dist[maxn];
int path[maxn][maxn],pre[maxn];
bool used[maxn][maxn],vis[maxn];
int N,M;

int Prim(){
    int sum=0,i,j;
    memset(vis,0,sizeof(vis));
    memset(used,0,sizeof(used));
    memset(path,0,sizeof(path));
    vis[1]=1;
    for(i=1;i<=N;i++){
        dist[i]=m[1][i];
        pre[i]=1;
    }
    for(i=1;i<N;i++)
    {
        int u=-1;
        for(j=1; j<=N;j++)
        {
            if(!vis[j])
            {
                if(u==-1||dist[j]<dist[u])
                    u=j;
            }
        }
        used[u][pre[u]]=used[pre[u]][u]=true;
        sum+=m[pre[u]][u];
        vis[u]=1;
        for(int j=1; j<=N;j++)
        {
            if(vis[j]&&j!=u)
            {
                path[u][j]=path[j][u]=max(path[j][pre[u]],dist[u]);
            }
            if(!vis[j])
            {
                if(dist[j]>m[u][j])
                {
                    dist[j]=m[u][j];
                    pre[j]=u;
                }
            }


        }
    }
    return sum;
}


int main()
{
    int t,i,j;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&N,&M);
        for(i=0;i<=N;i++)
            for(j=i+1;j<=N; j++)
                m[i][j]=m[j][i]=inf;
        int u,v,w;
        for(i=1;i<=M;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            m[u][v]=m[v][u]=w;
        }
        int Mst=Prim();
        int res=inf;
        for(i=1; i<=N;i++)
        {
            for(j=1; j<=N;j++)
                if(i!=j)
                {
                    if(!used[i][j])
                        res=min(res,Mst+m[i][j]-path[i][j]);
                }
        }
        cout<<res;
    }
    return 0;
}

2.先做一次最小生成树，但是在给原先最小生成树加边之前用倍增lca预处理出每两点之间的最大值和次大值（适用于顶点数，边数较大的情况）

代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<bits/stdc++.h>
#include<ctime>
using namespace std;
const int inf=1000000000;
const int maxn=100005;
const int maxm=300005;
int N,M,tot=0,ans=inf;
long long mst;
int head[maxn],fa[maxn],dep[maxn];
bool vis[maxm];
int anc[maxn][20],max1[maxn][20],max2[maxn][20];
struct node{int to,w,next;}e[maxm*2];
struct edge{int u,v,w;}q[maxm*2];
inline int read(){
int x=0;char ch=getchar();
while(ch<'0'||ch>'9'){ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x;
}


inline void addedge(int u,int v,int w){
e[++tot].to=v;e[tot].w=w;e[tot].next=head[u];head[u]=tot;
e[++tot].to=u;e[tot].w=w;e[tot].next=head[v];head[v]=tot;
}


inline int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}

bool cmp(edge a,edge b){return a.w<b.w;}

inline int Min(int x,int y){if(x<y)return x;else return y;}
inline int Max(int x,int y){if(x>y)return x;else return y;}

inline void dfs(int x,int father){
register int i;
for(i=1;i<=17&&(1<<i)<=dep[x];i++){
anc[x][i] = anc[anc[x][i-1]][i-1];
int Next = anc[x][i-1];
max1[x][i] = Max(max1[x][i-1],max1[Next][i-1]);
if(max1[x][i-1] != max1[x][i]) max2[x][i] = Max(max2[x][i],max1[x][i-1]);
if(max1[Next][i-1] != max1[x][i]) max2[x][i] = Max(max2[x][i],max1[Next][i-1]);
if(max2[x][i-1] != max1[x][i]) max2[x][i] = Max(max2[x][i],max2[x][i-1]);
if(max2[Next][i-1] != max1[x][i]) max2[x][i] = Max(max2[x][i],max2[Next][i-1]);
}
for(i=head[x];i;i=e[i].next){
if(e[i].to!=father){
anc[e[i].to][0]=x;
   max1[e[i].to][0]=e[i].w;
   dep[e[i].to]=dep[x]+1;
   dfs(e[i].to,x);
}
}
}


inline int lca(int x,int y){
register int i;
if(dep[x]<dep[y])swap(x,y);
int depth=dep[x]-dep[y];
for(i=0;i<=17&&(1<<i)<=depth;i++)
   if((1<<i)&depth)
   x=anc[x][i];
for(i=17;i>=0;i--){
if(anc[x][i]!=anc[y][i]){
x=anc[x][i];
y=anc[y][i];
}
}
if(x==y)return x;
else return anc[x][0];
}


inline void work(int x,int y,int W)
{
register int ans1=0,ans2=0,i;
if(dep[x]<dep[y])swap(x,y);
int depth=dep[x]-dep[y];
for(i=0;i<=17&&(1<<i)<=depth;i++){
if((1<<i)&depth){
if(max1[x][i]>ans1){
ans2=ans1;
ans1=max1[x][i];
}
ans2=Max(ans2,max2[x][i]);
x=anc[x][i];
}
}
if(W==ans1)ans=Min(ans,W-ans2);
else ans=Min(ans,W-ans1);
}


int main(){
    register int i,j,count=0;
    N=read();M=read();
    register int u,v,w;
    for(i=1;i<=N;i++)fa[i]=i;
    for(i=1;i<=M;i++){q[i].u=read();q[i].v=read();q[i].w=read();}
    sort(q+1,q+1+M,cmp);
    for(i=1;i<=M;i++){
    int x=find(q[i].u);
    int y=find(q[i].v);
    if(x!=y){
    fa[x]=y;
    vis[i]=1;
    addedge(q[i].u,q[i].v,q[i].w);
    mst+=q[i].w;
    if(++count==N-1)break;
    }
    }
    dfs(1,0);
    for(i=1;i<=M;i++){
    if(!vis[i]){
    int U=q[i].u,V=q[i].v,W=q[i].w;
    int LCA=lca(U,V);
    work(U,LCA,W);
    work(V,LCA,W);
    }
    }
    printf("%lld\n",mst+ans);
    return 0;
}


yuzhuoranf22
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现最小生成树构造算法
01-21
最小生成树 最小生成树（minimum spanning tree）是由n个顶点，n-1条边，将一个连通图连接起来，且使权值最小的结构。 最小生成树可以用Prim（普里姆）算法或kruskal（克鲁斯卡尔）算法求出。 我们将以下面的带权...
最小生成树&次小生成树算法精讲
吾谁知
10-31 2740
最小生成树 定义 最小生成树，是在一个n点边的强连通无向图中，边权值之和最小的n点n-1条边的强连通量（树），一般情况下可以与并查集同解，常见的使用prim和kruskal。 性质 MST性质：设G=(V，E）是一个连通网络，U是顶点集V的一个非空真子集。若(u，v）是G中一条“一个端点在U中（例如：u∈U），另一个端点不在U中的边（例如：v∈V-U），且（u，v）具有最小权值，则一定存在...
最小生成树及次小生成树
qq_56769724的博客
05-30 171
问题描述： In order to prepare the “The First National ACM School Contest” (in 20??) the major of the city decided to provide all the schools with a reliable source of power. (The major is really afraid of blackoutsJ). So, in order to do that, power station “F
生成树(最小生成树，次小生成树，kruskal重构树)
weixin_43602607的博客
11-29 290
一.最小生成树 1.定义 在一个含有n个节点的无向图中，找到一棵含有n个节点的树，且该树边权总和最小 2.算法 prim，贪心，O(m) 3.实现过程 1.假设没有边，这n个都为独立的n个点，准备通过边来连接这n个点 2.对所有边排序，从最小的边开始选择是否连接 3.若边上两点已经间接连接，则continue 否则：将其连接，将边权加入sum 4.结果：n个点均直接或间接连接，break 判断是否间接连接？？？ 我们用并查集来写 4.代码实现 #include<bits/stdc++.h&
次小生成树算法
码农的一亩三分地
07-28 5292
定义: 　　设G = (V, E)是连通的无向图,T是图G的一个最小生成树.如果有另外一棵树T1,T1 ≠ T,满足不存在树T',T' ≠ T,w(T') &lt; w(T1),则称T1是图G的次小生成树. 算法: 1:基本算法 　　最简单也最容易想到的是,设T是G的最小生成树,依次枚举T的边并去掉,再求最小生成树,所得到的这些值的最小值就是次小生成树,由于最小生成树有N-1条边,这种方法...
prim算法--prim算法求次小生成树--prim算法求限制K度生成树
GameRoad
11-10 1712
在正常求次小生成树的时候相信大家都喜欢kruskal，毕竟因为太大的图，尤其是稀疏图，prim算法并不实用，而且占内存太多，有可能不让开。但是在解决次小生成树和限制度生成树时候prim算法不失为一种很好的方法，因为这两种情况空间复杂度，尤其是图的大小都并不太大。 从一开始学了prim算法，再到拿prim算法解决次小生成树的变形，直到今天彻底搞懂prim算法求解限制k度最小生成树的问题。我感觉无论
最小生成树_最小生成树_
10-04
最小生成树是图论中的一个重要概念，特别是在网络优化问题中有着广泛应用。在无向图中，如果每条边都有一个非负权重，那么最小生成树就是连接所有节点的一个子集，使得这棵树中的边的总权重尽可能小。这个问题最早由...
遗传算法求解最小生成树源码
05-17
最小生成树问题时指在由m个节点和n条边组成的网络模型中寻找连接所有节点的生成树，使得其所有边的权值之和最小。最小生成树问题广泛应用于系统设计、选址规划等组合优化问题中。
代码 最小生成树Prim算法代码
06-04
代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小生成树Prim算法代码代码 最小...
Prim与Kruskal算法的最小生成树matlab实现
05-26
最小生成树是图论中的一个重要概念，用于寻找一个无向加权图的边集合，使得这些边连接了图中的所有顶点，且总权重尽可能小。在这个集合中，任何两个顶点之间都有一条路径，但不存在环路。在实际应用中，如网络设计、...
次小生成树模板-prim算法
GameRoad
11-08 2731
prim算法的次小生成树构造：         与原版求最小生成树的prim算法相比，  在求解次小生成树时加入了maxx这个数组，也是最为核心的一个，以及一个connect数组下面重点说一下这两个新的内容。 connect数组，标志这connect[i][j]  从i到j有边，（这个在输入的时候就可以处理），其次，我们在求解最小生成树时候index点，也是这步需要添加到已经遍历到树中的点。我
最小生成树Prim算法理解
热门推荐
在路上的学习者
08-16 17万+
MST（Minimum Spanning Tree，最小生成树）
次小生成树问题——秘密的牛奶运输
AKAPinkman的博客
02-19 592
题目描述 算法 本题是一个裸的严格次小生成树问题。所谓严格就是该次小生成树的总边权严格大于最小生成树（以下用MGT称呼）。非严格的就是边权和MGT相同 算法1： 自然的想先求MGT，再每次删去MGT中的一条边，在该图上做MGT求解（新图的MGT就是原图的次小生成树）。做一遍kruskal后面就不用再排序了，删边次数n - 1，每次求MGT是m，故 O(mlogm+nm)O(mlogm + nm)O(mlogm+nm)。 这种方法求不出 严格次小生成树，因为如果有非严格次小生成树，删边之后再找肯定会找到非
次最小生成树
weixin_44091157的博客
05-28 663
最小生成数 常用的算法有俩中Prime和Kruskal prime算法简介 kruskal算法简介 对输入的数据距离进行排序，然后开始把每条边相连若他们相连后不能构成环则相连，否则则不连 这里我用到的是 用prime算法解决的prime算法 #include<iostream> #include<stdio.h> #include<string.h> #inc...
POJ 2831 Can We Build This One：次小生成树【N^2预处理】
a1392136的博客
12-20 89
题目链接：http://poj.org/problem?id=2831 题意： 　　给你一个图，每条边有边权。 　　然后有q组询问(i,x)，问你如果将第i条边的边权改为x，这条边是否有可能在新的最小生成树中。 题解： 　　更改边权相当于新添加了一条边。 　　新边在新MST中的充要条件是： 　　　　加入新边后，在原来的MST上形成的环中，有一条旧边的边权>=x。...
次小生成树
孙佰贵的专栏
10-11 5277
次小生成树的定义设 G=(V,E,w)是连通的无向图，T 是图G 的一个最小生成树。如果有另一棵树T1，满足不存在树T’,ω（T’）求解次小生成树的算法约定：由T 进行一次可行交换得到的新的生成树所组成的集合，称为树T的邻集,记为N(T)。定理 3：设T是图G的最小生成树，如果T1满足ω(T1)=min{ω(T’)| T’∈N(T)},则T1是G的次小生成树。证明：如果 T1 不是G 的次小生
最小生成树 次小生成树
qq_38367681的博客
07-28 223
老实说看完并查集再看最小生成树已经没什么意思了，在kuangbin大佬的训练题中没有什么特别有难度的，除了次小生成树。先挂两个板子。（最小生成树的学习可以借鉴《图论与集合》，或者各位大佬的博客） #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt...
最小生成树算法详解与实现
最小生成树是生成树的一个特例，它的边权重之和尽可能小。寻找最小生成树有多种算法，如Prim算法和Kruskal算法。 1. Prim算法，也称为贪心算法，从任意一个顶点开始，逐步选择边来扩展生成树，每次选择一条与当前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值