无向最小生成树（prim 与krusckal）总结

之前学的时候一直感觉是两个算法没什么区别，今天总结一下：

大体思路：

prim算法是做N次确定每一个点,使其构成最小生成树。

而相对比的是krusckal算法是做n-1次，找到N-1条最短边，以此来确定N个点。

假设给定N个点，以及M条边，既然是无向的，且有可能使其连通，那么边数M必定是 N-1<= M <=n*(n-1)/2。

下面给出代码和具体差别的思路想法：

1.prim算法（确定点）

算法的思想：

标记当前点（思路二的实现，思路一只是第一次空跑）

步骤： 取第一个点，进行向外找到当前这一个点可以到达的最短的边，sum+=边长，标记当前找到的点，防止以后再次访问该点。

    在当前已经拿到的两个点，找下一个使用最小的权值可以到达的另外一个没标记过的点。

    在当前已经拿到的三个点，找。。。。。。。。。。。。。。。。。。。。。。。。。。

    依次类推。到最后我们拿到了N个点，也就是N-1条边，这就是最小的生成树，即最小的权值和。

看了下网上各位的思路有两种：

第一种是循环n次，

这个N分为了{ 1，  2~N-1}  

其中第一步是确定了当前使用的点，是空跑，当前权值并不发生改变。先给出第一种的代码：

#include <iostream>
#include <stdio.h>
#define INF 99999999
using namespace std;
int n,m;
int mp[1005][1005];
int vis[1005];
int dis[1005];

void prim(int cur)
{
    int sum=0;
    for(int i=2;i<=n;i++)
    {
        dis[i]=mp[cur][i];
    }
    int index=cur;
    int minn=INF;
    for(int k=1;k<=n;k++)
    {
    minn=INF;
    for(int i=1;i<=n;i++)//注意这里是1~N N次找点循环，注意确定的是点，而非边。
    {
        if(vis[i]==0&&dis[i]<minn)
        {
            index=i;
            minn=dis[i];
        }
    }
    sum+=minn;
    vis[index]=1;
    for(int j=1;j<=n;j++)
    {
        if(!vis[j])
        dis[j]=min(dis[j],mp[index][j]);
    }
    }
    cout<<sum<<endl;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            mp[i][j]=INF;
    for(int i=1;i<=m;i++)
    {
        int x,y,p;
        cin>>x>>y>>p;
        mp[x][y]=p;
        mp[y][x]=p;
    }
    prim(1);
    return 0;
}

再给出第二种代码：

是N-1次循环，因为在初始时已经确立了X点（比如vis[1]）为起始点，进行多次寻找。

#include <iostream>
#include <stdio.h>
#define INF 99999999
using namespace std;
int n,m;
int mp[1005][1005];
int vis[1005];
int dis[1005];

void prim(int cur)
{
    int sum=0;
   
    for(int i=2;i<=n;i++)
    {
        dis[i]=mp[cur][i];
    }
    int index=cur;
    int minn=INF; 
    vis[1]=1;<span style="white-space:pre">		</span>//区别在这里和下一行。
    for(int k=1;k<=n-1;k++)//
    {
    minn=INF;
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==0&&dis[i]<minn)
        {
            index=i;
            minn=dis[i];
        }
    }
    sum+=minn;
    vis[index]=1;
    for(int j=1;j<=n;j++)
    {
        if(!vis[j])
        dis[j]=min(dis[j],mp[index][j]);
    }
    }
    cout<<sum<<endl;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            mp[i][j]=INF;
    for(int i=1;i<=m;i++)
    {
        int x,y,p;
        cin>>x>>y>>p;
        mp[x][y]=p;
        mp[y][x]=p;
    }
    prim(1);
    return 0;
}

2.Kruskal算法

  感觉还是很好理解的，看了别人的思路，可以自己手敲一遍，自己都可以按照学过的知识敲出来。

算法思路：

N个点可以由N-1条边连通，在不添加多余边的情况下，我们自然要找到这N-1条边是哪些边。

首先我们将这N个顶点看成N棵孤立的树，接下来的操作是每一条边将st ed两个顶点连接。

当然如果这两个顶点已经在同一棵树上了，那么我们这条边加上后就一定会形成一个圈，就浪费了这个权值，所以只有当两个点不在一棵树上的时候我们才进行连接。

那么上述操作就是一个并查集合并根节点的操作。

而这些边的选取规则是从小到大依次选取，只要这条边加入后不会形成圈（也就是边的两个点原来不在同一棵树上）。

我们可以记录一下我们已经加入了多少条边，当边数==N-1时候退出。

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int father[50005];
struct node
{
    int st;
    int ed;
    int val;
}edge[50005];
int vis[50005];
int n,m;
int sum=0,temp=0;
int cmp(node x,node y)
{
    return x.val<y.val;
}
void init()
{
    for(int i=1;i<=50005;i++)
    father[i]=i;
    return ;
}
int find(int x)
{
    if(father[x]!=x)
        father[x]=find(father[x]);
    return father[x];
}
void kruskal()
{
    for(int i=1;i<=m;i++)
    {
        if(temp==n-1)
            continue ;
        int root1=find(edge[i].st);
        int root2=find(edge[i].ed);
        if(root1==root2)
            continue;
        sum+=edge[i].val;
        father[root2]=root1;
        temp++;
    }
    cout<<sum<<endl;
}
int main()
{
    init();
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>edge[i].st>>edge[i].ed>>edge[i].val;
    }
    sort(edge+1,edge+1+m,cmp);
    kruskal();
    return 0;
}