Algorithm Design——最小生成树

本文主要介绍了最小生成树的两种解决办法：kruskal以及prim 

/**
Kruskal算法流程：
    （1）初始时所有节点属于孤立的集合；
    （2）按照边权递增顺序遍历所有的边，若遍历到的边两个节点仍分属于不同的
    集合（该边即为联通这两个结合的边中权值最小的那条），则确定该边为最小生
    成树上的一条边，并将这两个顶点分属的集合合并；
    （3）遍历完所有的边之后，原图上所有节点属于同一个集合则被选取的边和原图
    中所有节点构成最小生成树；否则原图不连通，最小生成树不存在。


样例输入： 
3
1 2 1 
1 3 2 
2 3 4 
4
1 2 1 
1 3 4 
1 4 1 
2 3 3
2 4 2 
3 4 5 
0
样例输出： 
3 
5
*/

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

#define N  101

int Tree[N];

int findRoot(int x)//找到代表集合的树的根节点
{
    if(Tree[x] == -1)
        return x;
    else
    {
        int tmp = findRoot(Tree[x]);
        Tree[x] = tmp;//x直接指向根节点
        return tmp;
    }
}

struct Edge//边结构体
{
    int a,b;//边两个顶点的编号
    int cost;//该边的权值

    bool operator < (const Edge &A) const//重载<运算符
    {
        return cost < A.cost;
    }
}edge[6000];

int main()
{
    int n;
    while(scanf_s("%d", &n) != EOF && n != 0)
    {
        for(int i = 1 ; i <= n * (n - 1) / 2 ; i ++)
        {
            scanf_s("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].cost);//输入边的顶点以及权值
        }

        sort(edge + 1, edge + 1 + n * (n - 1) / 2);//按照边权值递增排序所有的边

        for(int i = 1 ; i <= n ; i ++)
        {
            Tree[i] = -1;//初始时所有的节点都是孤立的集合
        }

        int ans = 0;//最小生成树上边权值的和，初始值是0
        for(int i = 1 ; i <= n * (n - 1) / 2 ; i ++)//按照权值递增顺序遍历所有的边
        {
            int a = findRoot(edge[i].a);
            int b = findRoot(edge[i].b);//查找该边两个顶点的信息结合

            if(a != b)//若它们属于不同的集合，则选用该边
            {
                Tree[a] = b;//合并两个集合
                ans += edge[i].cost;//累加该边权值
            }
        }

        printf_s("%d
", ans);//输出
    }
}

 /**
prim算法流程：
（1）设置两个集合V和S，任意选择一个顶点作为起始顶点，将起始顶点放入集合S，
其余顶点放入集合V；
（2）然后使用贪心策略，选择一条长度最短并且顶点分别在S和V中的边（即为最小
生成树中的一条边），将这条边在V中的顶点加入到集合S中；
（3）循环执行（2），直到S中包含了所有顶点。

样例输入： 
3
1 2 1 
1 3 2 
2 3 4 
4
1 2 1 
1 3 4 
1 4 1 
2 3 3
2 4 2 
3 4 5 
0
样例输出： 
3 
5
*/

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

#define MaxInt 0x3f3f3f3f
#define N 110
int n;

int map[N][N];//存放图
int low[N];//存放每两个节点之间最小权值
int visited[N];//标记某节点是否已经被访问

int prim()
{
    int pos, min, result = 0;
    memset(visited, 0, sizeof(visited));

    //从某点开始，分别标记和记录该点
    visited[1] = 1;
    pos = 1;

    for(int i = 1; i <= n ; i ++)
    {
        if(i != pos)
            low[i] = map[pos][i];
    }

    for(int i = 1; i < n; i ++)
    {
        min = MaxInt;
        //找到最小生成树节点集合K与剩余节点集合之间距离最小的点
        for(int j = 1; j <= n; j ++)
        {
            if(visited[j] == 0 && min > low[j])
            {
                min = low[j];
                pos = j;
            }
        }

        result += min;//最小权值累加
        visited[pos] = 1;//标记该点
        //更新权值
        for(int j = 1 ; j <= n ; j ++)
        {
            if(visited[j] == 0 && low[j] > map[pos][j])
                low[j] = map[pos][j];
        }
    }

    return result;
}

int main()
{
    int ans;

    while(scanf_s("%d", &n) != EOF && n != 0)
    {
        memset(map, 0, sizeof(map));
        int a, b, c;
        for(int i = 1 ; i <= n * (n - 1) / 2 ; i ++)
        {
            scanf_s("%d%d%d", &a, &b, &c);//输入边的顶点以及权值
            map[a][b] = c;
            map[b][a] = c;
        }

        for(int i = 1 ; i <= n ; i ++)
        {
            for(int j = 1 ; j <= n ; j ++)
            {
                if(i == j)
                    map[i][j] = 0;
                else if(map[i][j] == 0)
                    map[i][j] = MaxInt;
            }
        }

        ans = prim();
        printf_s("%d
", ans);
    }
}