最小生成树

开始接触图论了，开始学的是最小生成树，教了基本上一个下午的时间，在加上这几天做了一些最小生成树的样本题，

就想来写写自己最近所学。

图的存储有两种方法一个是矩阵，一个是邻接表。

矩阵：比较好理解，其所存储的值就是两个节点的权值。

邻接表：要用到链表的那种思想，用数组来转换这种思想。

优缺点：

矩阵空间复杂度大，而且不能处理重边，查询一个节点所有的边，要

枚举其全部；但是查询任意两个节点方便，直观容易理解，

链表跟其相反，空间复杂度比之较低，适合用于一些稀疏图、

接下来介绍做最小生成树的两种算法：

1、普里姆算法（Prim）

这种算法的思路是这样的：

分别使用集合A，集合B表示。

开始集合A存放所有的节点，B集合为空

从A集合中选择一个节点放入B集合。

这一个节点的选举时根据距离最小来选。

然后在A、B两个集合中选举出最小的距离的两个节点，将其从

A集合拿到B集合。

就这样一直循环操作，到最后就是最小的节点链接起来就是最短的。

代码如下：

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
const int inf=1<<29;
const int maxn=1011;
int n,m,w[maxn][maxn];
bool vis[maxn];
int dist[maxn];//存储节点的距离，从中选出来最小距离的节点。
int Prim()
{
    int ans=0;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
        dist[i]=w[1][i];
    vis[1]=1;
    for(int i=1;i<n;i++)
    {
        int mini=inf,u=-1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dist[j]<mini)
            {
                mini=dist[j];
                u=j;
            }
        }
        if(u==-1)
        {
            //处理无法构成最小生成树
            break;
        }
        ans+=mini;
        vis[u]=1;
        //printf("%d %d\n",u,mini);
        for(int j=1;j<=n;j++)
        {
            dist[j]=min(dist[j],w[u][j]);
        }
    }
    printf("\n");
    return ans;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
                w[i][j]=inf;
        for(int i=0;i<m;i++)
        {
            int u,v,c;
            scanf("%d%d%d",&u,&v,&c);
            w[u][v]=w[v][u]=c;
        }
        printf("%d\n",Prim());
    }
    return 0;
}

Prim算法还有一种写法就是用邻接表来写：

他的核心算法就是：

void AddEdge(int u,int v,int c)
{
    pnt[e]=v;
    cost[e]=c;
    nxt[e]=head[u];
    head[u]=e++;
}

这是类似于链表的存放来实现的。

head[]数组类似于头节点，cost[]、pnt[]分别存储权值和指向的节点。nex[]起到一个指针域的作用。

完整的代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
const int maxn =1001;
const int inf=1<<29;
const int maxm=maxn*maxn/2;
int e,head[maxn],pnt[maxm],nxt[maxm],cost[maxm];
int n,m,dist[maxn];
bool vis[maxn];
void AddEdge(int u,int v,int c)
{
    pnt[e]=v;
    cost[e]=c;
    nxt[e]=head[u];
    head[u]=e++;
}
int Prim()
{
    int ans=0;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
        dist[i]=inf;
    vis[1]=1;
    for(int i=head[1];i!=-1;i=nxt[i])
        dist[pnt[i]]=cost[i];//将1到其他的点权值赋给dist[]数组；
    for(int j=1;j<n;j++)
    {
        int mini=inf,u=-1;
        for(int i=1;i<=n;i++)
            if(dist[i]<mini&&!vis[i])
        {
            mini=dist[i];
            u=i;
        }
        if(u==-1)
            break;//wrong
        ans+=mini;
        vis[u]=1;
        for(int i=head[u];i!=-1;i=nxt[i])//找出与之前最小的之后，进行最小值比较。
            dist[pnt[i]]=min(dist[pnt[i]],cost[i]);
    }
    return ans;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        e=0;
        memset(head,-1,sizeof(head));
        for(int i=0;i<m;i++)
        {
            int u,v,c;
            scanf("%d%d%d",&u,&v,&c);
            AddEdge(u,v,c);
            AddEdge(v,u,c);
        }
        printf("%d\n",Prim());
    }
    return 0;
}

2、克鲁斯卡尔算法:

思路大概是这样的：首先从权值最小的边开始，

如果添加的另一个边不让他构成回路的话，就加上这一条边，

这里就要求并查集，使用的最简单的并查集就这样一直重复，

知道加到N-1条边。

这种算法的时间复杂度比上面的则少点。

代码如下、

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1100;
struct Node
{
    int from;
    int to;
    int w;
    bool operator< (const Node &a)const
    {
        return w<a.w;
    }
}E[maxn];
const int maxm=1e6;
int p[maxn];
int n,m;
int Find(int x)//用于判断是否构成回边。
{
    if(p[x]==-1)
        return x;
    return p[x]=Find(p[x]);
}
int Kruskal()
{
    int ans=0,cnt=0;
    for(int i=0;i<m;i++)
    {
        int x=Find(E[i].from);
        int y=Find(E[i].to);
        if(x!=y)
        {
            cnt++;
            ans+=E[i].w;
            p[x]=y;
        }
    }
    if(cnt<n-1)
        return -1;//无法构成最小生成树。
    return ans;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(p,-1,sizeof(p));
        for(int i=0;i<m;i++)
            scanf("%d%d%d",&E[i].from,&E[i].to,&E[i].w);
        sort(E,E+m);//排序可以将权值最小的优先选择。
        printf("%d\n",Kruskal());
    }
    return 0;
}