最小生成树总结

最小生成树

一.最小生成树问题
给定一张图，图中有许多的节点还有许多长度不同的边将这些点点相互连接，找出连接所有点的最短方式就是最小生成树，可以证明，这样一种最小的情况是不会出现环的，由于所有的无环图都可以看作树，所以成为最小生成树。
例如：这是一个图

它的最小生成树为：

下面有两种算法来运算：
1. prime算法：
以点为研究对象，将点分成两个集合：一个已经确定是最短路，一个还未确定；用最短路的思路选出n个点。适用于稠密图。
主要步骤：
1.将图保存在临接矩阵之中（便于访问是否邻接）；
2.任选一点作为起始点；
3.将此点加入到已确定点集之中；
4.依此点为原点，更新与之相关联的节点到点集的距离（最小）；
5. 选中剩余点中距离点集最近的点，加入点集，并以其为原点更新和他相邻接的点的距离………
6. 循环，直到点集中有n个点为止。
图形步骤：
原图为：

1.
首先先找一个点，把这个点看成一个集合

2.
找与这个点最近的一个点，也就是找与这个集合最近的一个点，由图可知与1点相邻的有2，3，4三个点，但最近的是2点，并且2点没在已选的集合中，所以把2点加到已选的集合中。

3.
现在1和2是在已选的集合中，然后再找与已选集合最近的点，其中相邻的有3，4，5三个点，但最近的只有点4，所以把4点加到已选集合中。

4.
然后再找与已选集合最近的点，以此类推下个点为3

再下个点为6

5.
最后一个点为5，选完所有点后结束。

代码如下：

prime:

#include<cstdio>
#include<cstring>
using namespace std;

#define inf 0x3f3f3f  
//#define INF 0x3f3f3f3f
const int MAXN=1e3+10;
int map[MAXN][MAXN],dis[MAXN];//保存图(顶点邻接矩阵）和点的距离 
bool vis[MAXN];//标记是否访问过 
int ans;//保存答案 

void prime(int n)
{
    memset(vis,false,sizeof(vis)); memset(dis,inf,sizeof(dis));
    ans=0; dis[1]=0;//初始化 任选一点作为原点 
    for(int i=1;i<=n;++i)//依次加入n个点 原点也算 
    {
        int top=inf,k;//记录距已确定集合最近的距离和这一点的下标 
        for(int j=1;j<=n;++j)//查找与已确定集合最近的点 
        {
            if(!vis[j]&&dis[j]<top)//此点没有加入已选集合且距离集合的距离最近 
            {
                top=dis[j];
                k=j;
            }
        }
        vis[k]=true; ans+=top;//将此点加入集合并更新结果 
        for(int j=1;j<=n;++j)//更新与已选点邻接节点的距离 
        {
            if(!vis[j]&&map[k][j]<dis[j])//如果此点没有加入集合且距离集合的距离有更新 
            {
                dis[j]=map[k][j];
            }
        }
    }
}

int main()
{
    int i,n,u,v,w;
    while(~scanf("%d",&n),n)
    {
        memset(map,inf,sizeof(map));//初始化所有点都距离无穷远 
        for(i=1;i<=n*(n-1)/2;++i)
        {
            scanf("%d %d %d",&u,&v,&w);
            map[u][v]=map[v][u]=w;//两点邻接 
        }
        prime(n);
        printf("%d\n",ans);
    }
    return 0;
}

2.kruskal算法

顶层思想是分治，选择策略是贪心，实现方法如下：以边为中心，先将所有的边从小到大进行排序，之后依照大小顺序依次选择，如果这条边连接的两个节点是不连通的（判断联通状态可以使用并查集），那么就选择这条边，否则就不选择，因为这个算法是以边为中心的所以用来计算稀疏图更快一些。
主要步骤：
1.将图保存在临接矩阵之中（便于访问是否邻接）；
2…先把所有的路径进行排序；
3.先选一天路径最小的边然后判断这两个点是否在同一个集合中，如果没有就把这两个点加到一个集合中；
4.然后依次找路径最小的边，并判断这条边上的两个点是否在同一个集合中，如果没在同一个集合中且这两个点没有都被标记过，就把这两个点合到同一个集合中；
5.循环来找，直到点找完为止。
图形步骤：
原图为：

1.
先找一条路径最小的边，由图可知有两条，可以先找先出现的一条。

2.
然后依次找路径最小的边，并判断这条边上的两个点是否在同一个集合中，如果没在同一个集合中且这两个点没有都被标记过，就把这两个点合到同一个集合中。

①

②

③

④

3.
最后找完结束。

问题描述
给定一个有权值的图，找出联通图内所有节点的最小路径。
数据

6 9
2 4 11
3 5 13
4 6 3
5 6 4
2 3 6
4 5 7
1 2 1
3 4 9
1 3 2

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int f[50];
struct line
{
    int u;
    int v;
    int w;
}lines[50];
int cmp(const void *a,const void *b)	//快排的从小到大的排序函数
{
    return (*(line *)a).w>(*(line *)b).w?1:-1;
}
void init(int n)	//初始化
{
    for(int i=1;i<=n;i++) f[i]=i;
}
int getf(int a)	//找亲戚
{
    if(f[a]==a) return a;
    else
    {
        f[a]=getf(f[a]);
        return f[a];
    }
}
int  merge(int a,int b)	//判断是否在一个集合里
{
    int t1,t2;
    t1=getf(a);
    t2=getf(b);
    if(t1!=t2)	//没在一个集合里合在一起并返回1
    {
        f[t2]=t1;
        return 1;
    }
    else return 0;
}
int main(int argc, const char * argv[]) 
{
    int n,m,sum;
    sum=0;
    cin>>n>>m;
    init(n);
    for(int i=0;i<=m-1;i++)
    {
        cin>>lines[i].u>>lines[i].v>>lines[i].w;
    }
    qsort(lines,m,sizeof(lines[0]),cmp);	//快排
    for(int i=0;i<=m-1;i++) 
        cout<<lines[i].w<<" ";	//输出排好序的路权
    cout<<endl;
    for(int i=0;i<=m-1;i++)
    {
        if(merge(lines[i].u,lines[i].v)==1)	//组合的最小生成树所需的路
        {
            sum+=lines[i].w;	
            cout<< lines[i].w <<" ";
        }
    }
    cout<<endl;
    cout<<sum<<endl;
    return 0;
}