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

首先了解一下最小生成树：参考https://blog.****.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的点的最小权值。

    }

    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<cstdio>

#include<algorithm>

#include<cmath>

using namespace std;

struct Island

{

	int x,y;

};

struct node 

{

	int u,v;

	double w;

};

Island arr[220];

node  edge[20000];

int per[220];

int n;

bool cmp(node a,node b)

{

	return a.w<b.w;

}

void init()

{

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

	{

		per[i]=i;

	}

}

int find(int x)

{

	if(x==per[x]) return x;

	return per[x]=find(per[x]);

}

bool join(int x,int y)

{

	int fx=find(x);

	int fy=find(y);

	if(fx!=fy)

	{

		per[fx]=fy;

		return 1;

	} 

	return 0;

}

int main()

{

	int T;

	int i,j,k;

	double x,y;

	scanf("%d",&T);

	while(T--)

	{

		

		scanf("%d",&n);

		init();

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

		{

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

		}

		//m=n*(n-1)/2;

		k=0;

		for(i=1;i<=n;++i)//把所有路记录在node结构体中

		{

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

			{

				edge[k].u=i;

				edge[k].v=j;

				x=(arr[j].y-arr[i].y)*(arr[j].y-arr[i].y);

				y=(arr[j].x-arr[i].x)*(arr[j].x-arr[i].x);

				double temp=sqrt(x+y);

				edge[k++].w=temp;

			}

		}		

		sort(edge,edge+k,cmp);

		double sum=0;

		for(i=0;i<k;++i)

		{

			if(edge[i].w<=1000&&edge[i].w>=10&&join(edge[i].u,edge[i].v))//如果两个岛的距离不符合要求就会把join(edge[i].u,edge[i].v）短路

			{

				sum+=edge[i].w;

			}

		}

		int cnt=0;

		bool flag=0;

		for(i=1;i<=n;++i)//短路了就不会执行了，也就不会连接了，就只需要判断根节点的个数

		{

			if(i==per[i]) cnt++;

			if(cnt>1) //不等于1就还有元素（小岛）没连起来，不满足题意

			{

				flag=1;

				break;

			}

		}

		if(flag) printf("oh!\n");

		else

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

	}

	return 0;

}

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;

}

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

1.Kruskal算法

2.Prim算法

畅通工程1

Kruskal算法：贪心+并查集

Prim算法

畅通工程 2

1414.2 oh! 17335

Prim

相关推荐

1414.2
oh!
17335