最小生成树-Prim算法

最小生成树minimal-spanning-tree(概念就不具体介绍了)有两种基于不同贪心选择的算法，一个为Prim算法，一个为Kruskal算法。

Prim和Dijkstra算法很像，只是少了些东西。它将结点分为两类，一类是已经选择了的确定的，构建好了的mst的结点，另一类是还没确定的未选择的结点。

流程是这样的：（括号内为权值），U集合：MST的点集合，V-U：未选择的点集合

1.首先初始化开始结点U，然后把所有能够与U相连的边为候选边

这里就是数组初始化操作了;

     int sum=0;
    for(int i=1;i<=n;i++)
    {
        dis[i]=map[1][i];//初始化所有点到结点1的距离
        vis[i]=false;//所有点开始都未被访问
    }
    vis[1]=true;//结点1标志为true

1

开始时U是结点1,然后找到所有与1相连的边(dist[i][j]!=0)，分别是1-6(10),1-2(28)，所以找出最小的(6<28)那个边对应的结点6加入集合U;

for(int i=2;i<=n;i++)
    {
        int MIN=INF;//从当前节点u到与u联通的子节点的最小权值
        int k=-1;
        for(int j=1;j<=n;j++)//遍历每个点
        {
            if(!vis[j]&&dis[j]<MIN)//未被访问且距离还小，那就待定选你了，看看还有没有距离更短的
            {
                MIN=dis[j];//更新最小值，这个dis表式这个点到已知mst中一点的最小值
                k=j;//标记结点号
            }
        }
        vis[k]=true;//u->a->b  k->b //置已经访问
        sum+=MIN;//u->k求生成树的路径和
        ...
        ...
       ...
}

 

然后我们发现，左部分和右部分只有两条边相连了，那么继续找最短边就行6-5(25) <1-2(28),所以选择25的那条边，成这样

再比较1-2(28),5-7(24),5-4(22)，取出最小边是5-4(22),更新图

继续比较选出最短边，这时有4个边要比较了，1-2(28),5-7(24),4-7(18),4-3(12),找出最短边4-3(12),更新图

继续比较4个个边，1-2(28),5-7(24),4-7(18),3-2(16)，找出最短的16,更新图

好了，最后已给点7,应该很容易看出来它是2连接的，因为14是最短的。

所以MST图是这样

后半段的代码是这样的

for(int j=1;j<=n;j++)//带已经找到点k的情况下，找结点j
        {
            if(!vis[j]&&dis[j]>map[k][j])
            {//j未访问且 j到mst中点的最小值还大于从k到j的距离，那么就   
//要更新这段距离
                dis[j]=map[k][j];//clost[j] = k;
            }
        }

看这个图

比如说开始先初始化，dist[6] =10;dist[4]=1,即结点6和4到结点1的最短距离为dist数组，然后我找到了最短路1-4,并且发现原来的1-6(10)大于6-4(5)，所以更新dist[6]=4,他表示结点6到已知MST的某个点的最短的那个距离，也可以将那个点记录在clost数组中，以便需要。

完整代码，其实很简单的

邻接矩阵：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=1005;
int map[MAXN][MAXN];   //map[i][j]   ----  i->j =v
int dis[MAXN];     //
bool vis[MAXN];
int n;
void init()
{
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=n;j++)
        {
            if(i!=j)map[i][j]=INF;
            else map[i][j]=0;
        }
    }
}
int Prim()
{
    int sum=0;
    for(int i=1;i<=n;i++)
    {
        dis[i]=map[1][i];
        vis[i]=false;
    }
    vis[1]=true;
    for(int i=2;i<=n;i++)
    {
        int MIN=INF;//从当前节点u到与u联通的子节点的最小权值
        int k=-1;//u->v k=v;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]<MIN)
            {
                MIN=dis[j];
                k=j;
            }
        }
        vis[k]=true;//u->a->b  k->b
        sum+=MIN;//u->k
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dis[j]>map[k][j])
            {
                dis[j]=map[k][j];
            }
        }
    }
    return sum;
}
int main()
{
    cin>>n;
    init();
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            int v;
            cin>>v;
            if(map[i][j]>v)
            {
                map[i][j]=map[j][i]=v;
            }
        }
    }
    int c;
    cin>>c;
    for(int i=1;i<=c;i++)
    {
        int a,b;
        cin>>a>>b;
        map[a][b]=map[b][a]=0;
    }
    /*for(int i=1;i<=n;i++)
    {
        int a,b,v;
        cin>>a>>b>>v;
        /*if(map[a][b]>v)
        {
            map[a][b]=map[b][a]=v;
        }
        map[a][b]=v;
    }*/
    cout<<Prim()<<endl;
    return 0;
}

邻接表：

/*************************************************************************
    > File Name: p3366.cpp
    > Author: YeGuoSheng
    > Description: 
最小生成树模板 、如题，给出一个无向图，求出最小生成树，如果该图不连通，则输出orz
输入格式
第一行包含两个整数N、M，表示该图共有N个结点和M条无向边。（N<=5000，M<=200000）

接下来M行每行包含三个整数Xi、Yi、Zi，表示有一条长度为Zi的无向边连接结点Xi、Yi

输出格式
输出包含一个数，即最小生成树的各边的长度之和；如果该图不连通则输出orz
输入输出样例
输入 #1 复制
4 5
1 2 2
1 3 2
1 4 3
2 3 4
3 4 3
输出 #1 复制
7
    > Created Time: 2019年08月02日 星期五 10时26分54秒
 ************************************************************************/

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cmath>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<list>
#include<queue>
#include<string>
#include<algorithm>
#include<iomanip>
using namespace std;
const int maxn = 500005;
const int INF = 0x3f3f3f3f;
int head[maxn];
int dis[maxn];
int vis[maxn];
int n,m;//顶点数，边数
struct edge
{
    int v;
    int w;
    int next;
}edges[maxn<<1];

int cnt = 1;

void Add(int x,int y,int w)
{
   edges[cnt].v = y;
   edges[cnt].w = w;
   edges[cnt].next = head[x];
   head[x] = cnt ++;
}   

void Init()
{
    cin>>n>>m;
    int x,y,w;
    for(int i = 1;i <= m;i++)
    {

        cin>>x>>y>>w;
        Add(x,y,w);//添加双向边
        Add(y,x,w);
    }
}

void Prim()
{
    int total = 0;
    int ans = 0;
    int now = 1;
    for(int i = 2;i <= n;i++)
    {
        dis[i] = INF;
    }

    for(int i = head[1];i;i=edges[i].next)
    {
        dis[edges[i].v] = min(dis[edges[i].v],edges[i].w);
    }//更新所有与起点1相连的边并找到最小值

    while(++total < n)//加入mst顶点数<图的顶点数即没找完，循环
    {
        int minn = INF;
        vis[now] = 1;
        for(int i = 1;i <= n;i++)
        {
            if (! vis[i] && minn > dis[i])//找到一条最短边
            {
                minn = dis[i];
                now = i;
            }
        }
        ans += minn;//当前找到的最短距离加入结果距离变量中
        for(int i = head[now]; i ; i =edges[i].next)//松弛操作
        {
            int v = edges[i].v;
            if(  ! vis[v]&& dis[v] > edges[i].w )
            {
                dis[v] = edges[i].w;
            }
        }
    }
    if(ans < INF)//找到解
    {
       cout<<ans<<endl;
    }
    else
    {
        cout<<"orz"<<endl;
    }
    
}
int main()
{
    Init();
    Prim();
    return 0;
}

传送门：Agri-Net