最小生成树 Prime Kruskal 算法

 Prime算法

二分的思想。将整个图分为A,B 两个部分，分别代表已选定的点和未选的点。

可以这样考虑，A是一块大陆，B是无数孤立的小岛，但A与B一开始是被海洋隔开的，只通过横跨海洋的几座桥相连，

现在需要找最短的“桥”。每找到这样的一座桥，就将A与B中的这个小岛之间的海填平，也就是A扩张了。如此循环往复，直到A大陆一统天下。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<iostream>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAX=20;
int length[MAX];
int check[MAX];
int graph[MAX][MAX];
int n,m;
int prime(int head)
{
    int i,p,j,all_length=0;
    int inf=INF,spot;

    for(i=1; i<=n; i++)
    {
        length[i]=graph[i][head];
        check[i]=head;
    }
    check[head]=-1;
    for(i=1; i<n; i++)
    {
        inf=INF;
        spot=head;
        for(j=1; j<=n; j++)
        {
            if(check[j]!=-1&&length[j]<inf)
            {
                inf=length[j];
                spot=j;
            }
        }
        if(inf!=INF)
        {
            check[spot]=-1;
            all_length+=length[spot];
            for(j=1; j<=n; j++)
            {
                if(check[j]!=-1&&graph[j][spot]<length[j])
                {
                    length[j]=graph[j][spot];
                    check[j]=spot;
                }
            }
        }

    }
    return all_length;
}
int main()
{
    int i,p,j,t;
    int a,b,c;
    scanf("%d%d",&n,&m);
    memset(graph,0,sizeof(graph));
    memset(check,0,sizeof(check));
    for(i=1; i<=m; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        graph[a][b]=graph[b][a]=c;
    }
    for(i=1; i<=n; i++)
        for(j=1; j<=n; j++)
        {
            if(i==j)
                graph[i][j]=0;
            else if(graph[i][j]==0)
                graph[i][j]=INF;
        }
    printf("%d\n",prime(1));
    return 0;
}

Kruskal 算法

以选择 边 为原则。

用到了以下几个概念：

1、将所有的边分成 A,B 两个集合,分别代表已选定的边和未选定的边。

2、因为每条边都有两个顶点，规定开始时，每条边的每个点都是不同“门派”的。

将边的权值从小到大遍历一遍，如果所遍历的边的两个点不是同一个门派的，就把它放到A集合中，代表选定，同时把该边的两个点统一门派（并查集的思想）；如果该边的两个点是同一个门派的，就说明，这条边所连接的两个点已经连通了，无需再连，直接pass掉就可以了。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<queue>
#include<stack>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int MAXN=20;
const int INF=0x3f3f3f3f;
struct edge
{
    int head,tail;
    int length;
} edge[MAXN];
int graph[MAXN][MAXN];

int captain[1000];
int m,n;
queue<struct edge> qq;
bool cmp(struct edge a,struct edge b)
{
    if(a.length==b.length)
        return a.head<b.head;
    return a.length<b.length;
}
void init()
{
    int i,j;
    for(i=1; i<=n; i++)
        captain[i]=i;
}
int seek(int x)
{
    while(x!=captain[x])
        x=captain[x];
    return x;
}
int Kruskal()
{
    struct edge k;
    int i,p,j,ans=0;
    int master1;
    int master2;
    while(!qq.empty())
    {

        k=qq.front();
        qq.pop();
        if(k.length!=INF)
        {
            master1=seek(k.head);
            master2=seek(k.tail);
            if(master1!=master2)
            {
                captain[master1]=master2;
                ans+=k.length;
            }
        }
    }
    return ans;
}
int main()
{
    int i,p=-1,j;
    int a,b,c;
    scanf("%d%d",&m,&n);

    memset(graph,0,sizeof(graph));
    memset(captain,0,sizeof(captain));
    init();
    for(i=1; i<=m; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        graph[a][b]=graph[b][a]=c;
    }


    for(i=1; i<=n; i++)
        for(j=1; j<=n; j++)
        {
            if(i<j)
            {
                edge[++p].head=i;
                edge[p].tail=j;
                if(graph[i][j]!=0)
                    edge[p].length=graph[i][j];
                else
                    edge[p].length=INF;
            }
        }
    sort(edge,edge+p+1,cmp);
    for(i=0; i<=p; i++)
        qq.push(edge[i]);
    printf("%d\n",Kruskal());
    return 0;
}