最小生成树入门---畅通工程续集系列

最新推荐文章于 2019-08-01 09:11:47 发布

CYB-just-go

最新推荐文章于 2019-08-01 09:11:47 发布

阅读量242

点赞数

分类专栏：最小生成树

本文链接：https://blog.csdn.net/CYBCLOUD/article/details/88384794

版权

最小生成树专栏收录该内容

1 篇文章 0 订阅

订阅专栏

首先了解一下最小生成树：参考https://blog.csdn.net/a2392008643/article/details/81781766

连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。
强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。
连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。
生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。
最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。

下面介绍两种求最小生成树算法

1.Kruskal算法

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。
1. 把图中的所有边按代价从小到大排序；
2. 把图中的n个顶点看成独立的n棵树组成的森林；
3. 按权值从小到大选择边，所选的边连接的两个顶点ui,viui,vi,应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。
4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

这里写图片描述

2.Prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

图的所有顶点集合为VV；初始令集合u={s},v=V−uu={s},v=V−u;
在两个集合u,vu,v能够组成的边中，选择一条代价最小的边(u0,v0)(u0,v0)，加入到最小生成树中，并把v0v0并入到集合u中。
重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。


struct

{

  char vertexData   //表示u中顶点信息

  UINT lowestcost   //最小代价

}closedge[vexCounts]

由于不断向集合u中加点，所以最小代价边必须同步更新；需要建立一个辅助数组closedge,用来维护集合v中每个顶点与集合u中最小代价边信息

这里写图片描述

Prim算法的时间复杂度都是和边无关的，都是O(n*n)，所以它适合用于边稠密的网建立最小生成树。但是了，克鲁斯卡算法恰恰相反，它的时间复杂度为：O(eloge)，其中e为边的条数，因此它相对Prim算法而言，更适用于边稀疏的网。

畅通工程1

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

Input

测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。

Output

对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。

Sample Input

Sample Output

3
?

Kruskal算法：贪心+并查集


# include <stdio.h>

# include <algorithm>

using namespace std;

 

struct node

{

    int a, b, c;

}nod[1001];

 

bool cmp(node a, node b)//贪心，将便宜的路放前面。

{

    return a.c < b.c;

}

 

int pre[1001];

int find(int x)

{

    if(x != pre[x])

        pre[x] = find(pre[x]);//压缩路径，降低树的高度。

    return pre[x];

}

int main()

{

    int n, m;

    while(~scanf("%d%d",&n,&m),n)

    {

        int ans = m-1, sum=0;//m条村至少要m-1条路。

        for(int i=1; i<=m; ++i)

            pre[i] = i;

        for(int i=0; i<n; ++i)

            scanf("%d%d%d",&nod[i].a,&nod[i].b,&nod[i].c);

        sort(nod, nod+n, cmp);

        for(int i=0; i<n; ++i)

        {

            int px = find(nod[i].a);

            int py = find(nod[i].b);

            if(px != py)

            {

                --ans;

                sum += nod[i].c;

                pre[px] = py;

                if(ans == 0)

                    break;

            }

        }

        if(ans == 0)

            printf("%d\n",sum);

        else

            puts("?");

    }

    return 0;

}

Prim算法


# include <stdio.h>

# define INF 0x3f3f3f3f

int sum, dis[101][101], lowcost[101];//lowcost数组为未进入MST的点指向已进入MST的所有点中权值最小的边.

bool prim(int n)

{

    int road = 0;

    for(int i=2; i<=n; ++i)

        lowcost[i] = dis[i][1];//预处理，从1开始，将所有最短距离指向点1。

    lowcost[1] = -1;

    for(int i=2; i<=n; ++i)

    {

        int minid = 0, imin = INF;

        bool flag = false;

        for(int j=2; j<=n; ++j)

            if(lowcost[j] < imin && lowcost[j] != -1)

            {

                flag = true;

                imin = lowcost[j];

                minid = j;

            }
        if(flag)

        {

            ++road;//记录边数，用于判断能否连通所有点。

            sum += imin;

            lowcost[minid] = -1;//该点进入MST，设为-1。

        }

        for(int j=1; j<=n; ++j)

            if(dis[j][minid] < lowcost[j])

                lowcost[j] = dis[j][minid];//找距离
//更新lowcast，找出所有未进入MST的点指向所有已进入MST的点的最小权值。仔细理解lowcasat[i]保存的是未进入点到已进入点的最小距离

    }

    if(road != n-1)

        return false;

    return true;

}

int main()

{

    int n, m, c, a, b;

    while(~scanf("%d%d",&m,&n),m)

    {

        sum = 0;

        for(int i=1; i<=n; ++i)

            for(int j=1; j<=n; ++j)

                dis[i][j] = dis[j][i] = INF;

        for(int i=1; i<=m; ++i)

        {

            scanf("%d%d%d",&a, &b, &c);

            if(dis[a][b] > c)//可能会有重边，取权值小的。

                dis[a][b] = dis[b][a] = c;

        }

        if(prim(n))

            printf("%d\n",sum);

        else

            puts("?");
        }
      return 0;

}

畅通工程 2
Problem Description

相信大家都听说一个“百岛湖”的地方吧，百岛湖的居民生活在不同的小岛中，当他们想去其他的小岛时都要通过划小船来实现。现在政府决定大力发展百岛湖，发展首先要解决的问题当然是交通问题，政府决定实现百岛湖的全畅通！经过考察小组RPRush对百岛湖的情况充分了解后，决定在符合条件的小岛间建上桥，所谓符合条件，就是2个小岛之间的距离不能小于10米，也不能大于1000米。当然，为了节省资金，只要求实现任意2个小岛之间有路通即可。其中桥的价格为 100元/米。

Input

输入包括多组数据。输入首先包括一个整数T(T <= 200)，代表有T组数据。
每组数据首先是一个整数C(C <= 100),代表小岛的个数，接下来是C组坐标，代表每个小岛的坐标，这些坐标都是 0 <= x, y <= 1000的整数。

Output

每组输入数据输出一行，代表建桥的最小花费，结果保留一位小数。如果无法实现工程以达到全部畅通，输出”oh!”.

Sample Input

2
2
10 10
20 20
3
1 1
2 2
1000 1000

Sample Output

1414.2
oh!
17335

Kruscal

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define ll long long
using namespace std;
struct node
{
    int x;
    int y;
    double w;
}a[101];
node b[100010];
int pre[101];
bool cmp(node a,node b)
{
    return a.w<b.w;
}
void init(int n)
{
     for(int i=0;i<n;i++)
        {
           pre[i]=i;
        }
}
int Find(int x)
{
    return x==pre[x]?x:pre[x]=Find(pre[x]);
}
int join(int x,int y)
{
      int px=Find(pre[x]);
      int py=Find(pre[y]);
      if(px!=py)
         {
             pre[px]=py;
             return 1;
         }
     else
        return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {

        int n;
        scanf("%d",&n);
        init(n);
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        double x,y;
        int k=0;
        for(int i=0;i<n;i++)
        {
            for(int j=i+1;j<n;j++)
            {
                x=pow((a[i].x-a[j].x),2);
                y=pow((a[i].y-a[j].y),2);
                b[k].w=sqrt(x+y);
                b[k].x=i;
                b[k].y=j;
                k++;
            }
        }
        sort(b,b+k,cmp);
        int ans=0;
        double sum=0;
        for(int i=0;i<k;i++)
        {
          if(b[i].w<=1000&&b[i].w>=10&&join(b[i].x,b[i].y))
          {
              sum+=b[i].w;
              ans++;
          }
        }
        if(ans!=n-1)
            puts("oh!");
        else
            printf("%.1f\n",sum*100);

    }

}

Prim


#include <stdio.h>

#include <string.h>

#include <math.h>

#define N 110

#define INF 0x3f3f3f3f

int n;

int i,j;

double map[N][N];

bool vis[N];//标记是否已经放入最小生成树的那个集合里了 

double low[N];//记录不在已经加入最小生成树的这个集合里的元素到这个 集合的最小距离 

int x[N],y[N];

double dis(int i,int j)

{

	return sqrt(1.0*(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));

} 

void input()

{

	for(i=1;i<=n;++i)

		scanf("%d%d",&x[i],&y[i]);

	for(i=1;i<=n;++i)

		for(j=1;j<=n;++j)

		{

			map[i][j]=dis(i,j);

			if(map[i][j]>1000||map[i][j]<10)

			{

				map[i][j]=INF;

			}					

		}		

}

void prim()

{

	double sum=0; 

	memset(vis,0,sizeof(vis));

	int pos=1;//从1开始 

	for(i=1;i<=n;++i)//第一次给low赋值 

	{

		low[i]=map[1][i]; 

	}

	vis[1]=1;

	//已经找到一个点1，再找n-1个

	for(i=1;i<n;++i)

	{

		double min=INF;

		for(j=1;j<=n;++j)

		{

			if(!vis[j]&&min>low[j])//找下一个点到这个集合的最小值 

			{

				min=low[j];//记下这个最小值 

				pos=j;//记下这个点 

			}

		}

		if(min==INF)

		{

			printf("oh!\n");

			return ;

		}

		sum+=min;

		vis[pos]=1;//把刚刚找到的这个点加入集合

		for(j=1;j<=n;++j) //更新low数组 

		{

			if(!vis[j]&&low[j]>map[pos][j])

			{

				low[j]=map[pos][j];

			}

		}

	}

	printf("%.1lf\n",sum*100); 

}

int main()

{

	int T;

	scanf("%d",&T);

	while(T--)

	{

		scanf("%d",&n);

		input();

		prim();

	}

	return 0;

}

CYB-just-go

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最小生成树入门---畅通工程续集系列

首先了解一下最小生成树：参考https://blog.csdn.net/a2392008643/article/details/81781766连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个...
复制链接

扫一扫