最小生成树——prim

最新推荐文章于 2024-11-13 19:50:30 发布

代码使人头秃/阔怕/

最新推荐文章于 2024-11-13 19:50:30 发布

阅读量85

点赞数

文章标签：图论 c++

本文链接：https://blog.csdn.net/weixin_45980432/article/details/118494466

版权

原题记录

描述

    某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

输入描述：

    测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。     当N为0时，输入结束，该用例不被处理。

输出描述：

    对每个测试用例，在1行里输出最小的公路总长度。

最小生成树是指图论中图的最小生成树，无向图的生成树即没有环，最小即树上的各边权重之和最小。其实就是把一个给定图删除几条边使它变成权重最小的一棵树

例如下图：

prim算法

算法思想：将顶点集分成两个， $V_{0}$ 和 $V_{1}$ ，初始状态为 $V_{1}$ 含有一个起始顶点v0，其他的顶点都在顶点集 $V_{0}$ 中，根据顶点之间边的关系，集合 $V_{0}$ 和集合 $V_{1}$ 之间有边相连

选取 $V_{0}$ 和 $V_{1}$ 之间的最小边，图中是1，是顶点v2和v0之间的边，将该边的另一个顶点v2合并到 $V_{1}$ 中，变成下图

接下来重复同样的操作，选择两个集合之间最小的边，进行合并（集合内部的边不考虑），直到 $V_{1}$ 包含所有的顶点为止。所有被选择的边加起来就是最小生成树的权重（未被选择的边可以删除）

代码实现：

1. 用visit[n]记录访问过和未访问过，0代表 $V_{0}$ 集，未访问；1代表 $V_{1}$ 集，已访问，已经访问的就不能重复访问了，否则会出现环。即每次选择的边的两个顶点，一个是已访问，一个是未访问。

2. 用side[n][n]记录边的权重，若为-1，则表示无边，注意side[i][j]=side[j][i]

3. 用容器road记录当前两个集合之间的可选择边，对其权重进行排序可以得到最短边

4. 首先初始化visit[n],都为0，然后将visit[0]置为1，即选择顶点0作为出发顶点，然后将顶点0的所有边加入road容器。

5. 开始循环：对road的边进行权重排序，取最小的边判断是否满足条件，若不满足取下一条边；若满足则将在 $V_{0}$ 中的那个顶点（假如是i）加入 $V_{1}$ ，visit[i]=1。然后将i的边中满足另一端顶点不在 $V_{1}$ 中的边，加入road，再将road中所有一端是i，一端在 $V_{1}$ 中的边删除。

6. 循环直到所有的顶点都被访问过了为止。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#define MAXN 105
using namespace std;

typedef struct Road{
    int start;
    int end;
    int cost;
};

vector<Road> road;
vector<Road>::iterator it;
int visit[MAXN];
int side[MAXN][MAXN];

void init(int n)
{
    memset(visit,0,sizeof(visit));
    memset(side,-1,sizeof(side));
}

bool compare(const Road a, const Road b)
{
    return a.cost<b.cost;
}

int main()
{
    int n,m;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0)break;
        int minlong=0;
        m=n*(n-1)/2;
        init(n);//visit初始化
        for(int i=0;i<m;i++)
        {
            int v1,v2;
            cin>>v1>>v2;
            cin>>side[v1][v2];
            side[v2][v1]=side[v1][v2];
        }
        visit[1]=1;//放入第一个初始顶点
        int number=1;
        for(int i=1;i<=n;i++)//放入初始边
        {
            if(side[1][i]!=-1)
            {
                Road temp;
                temp.start=1;
                temp.end=i;
                temp.cost=side[1][i];
                road.push_back(temp);
            }
        }

        while(number < n && road.empty()==0)
        {
            sort(road.begin(),road.end(),compare);//边排序
            for(it=road.begin();it!=road.end();it++)
            {
                if(visit[it->end]==0)//不在同一个集合的顶点，且边为最小
                {
                    //加入集合
                    visit[it->end]=1;
                    number++;
                    minlong+=it->cost;
                    //将边也加入进来
                    for(int i=1;i<=n;i++)
                    {
                        if(side[it->end][i]!=-1  && visit[i]==0)//将剩余的边加入进来
                        {
                            Road temp;
                            temp.start=it->end;
                            temp.end=i;
                            temp.cost=side[it->end][i];
                            road.push_back(temp);
                        }

                    }
                    break;
                }
            }
            //将集合内部的边删除
            int v=it->end;
            for(it=road.begin();it!=road.end();it++)
            {
                if(it->end==v)
                {
                    road.erase(it);
                    it--;
                }
            }
        }
        cout<<minlong<<endl;
    }
    return 0;
}