《算法笔记》10.5小节——图算法专题-＞最小生成树

最新推荐文章于 2022-10-24 10:07:41 发布
最新推荐文章于 2022-10-24 10:07:41 发布
阅读量268 收藏 1
点赞数
分类专栏： CSP刷题 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/susuate/article/details/119984788
版权

10.5.1 最小生成树及其性质

最小生成树是无向图中的一棵树，涵盖图G的所有顶点，并且边之和最小
最小生成树的三个性质：
1、是树，边数=顶点数-1
2、对于给定的图，最小生成树可以不唯一，但是边权值和是唯一的
3、最小生成树的根节点可以是任何一个节点，但是题目为了方便输出，一般会用题目给的节点作为根节点
P算法和K算法都是采用贪心法求最小生成树，只是贪心的策略不一样

10.5.2 prim算法

P算法与求最短路径的D算法思想几乎完全相同
区别是P算法中d[i]指的是点i距离集合S的距离
D算法中d[i]指的是点i距离起点S的距离
复杂度是O（V²），可以进行堆优化
尽量在图的顶点数目较少，而边数较多的时候使用prim算法

10.5.3 kruskal算法

采用边贪心的策略
时间复杂度主要来自对边的排序，为O（ElogE）,所以适合顶点较多，边较少的情况

习题

注意P算法适用于边较多的情况，K算法适用于顶点较多的情况
问题 A: 还是畅通工程
问题描述： 某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

  • 输入
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。```
 - 输出
 ```cpp
对每个测试用例，在1行里输出最小的公路总长度。
  • 样例输入
8
1 2 42
1 3 68
1 4 35
1 5 1
1 6 70
1 7 25
1 8 79
2 3 59
2 4 63
2 5 65
2 6 6
2 7 46
2 8 82
3 4 28
3 5 62
3 6 92
3 7 96
3 8 43
4 5 28
4 6 37
4 7 92
4 8 5
5 6 3
5 7 54
5 8 93
6 7 83
6 8 22
7 8 17
0
  • 样例输出
82

这题使用P算法：
因为是多点测试，注意要初始化所有的变量

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxv = 110;//表示最多100个村庄
const int INF = 1000000000;//无穷大
int n, m, G[maxv][maxv];
int d[maxv];
int vis[maxv];
int prim()
{
	fill(d, d + maxv, INF);
	fill(vis, vis + maxv, 0);
	d[1] = 0;
	int ans = 0;
	//首先找到距离集合S最小的点u以及距离d[u]
	for (int i = 1; i <=n; i++)
	{
		int u = -1,MIN = INF;
		for (int j = 1; j <= n; j++)
		{
			if (vis[j] == 0 && d[j] < MIN)
			{
				u = j;
				MIN = d[j];
			}
				
		}
		if (u == -1) return -1;
		vis[u] = 1;
		ans += d[u];
		for (int v = 1; v <= n; v++)
		{
			if (vis[v] == 0 && G[u][v] != INF && G[u][v] < d[v])
				d[v] = G[u][v];
		}
	}
	return ans;

}
int main()
{
	int u, v, w;
	while (scanf("%d", &n) != EOF)
	{
		if (n == 0)
			break;
		else
		{
			fill(G[0], G[0] + maxv * maxv, INF);
			int temp = n * (n - 1) / 2;
			for (int i = 1; i <= temp; i++)
			{
				scanf("%d%d%d", &u, &v, &w);
				G[u][v] = G[v][u] = w;
			}
			int ans = prim();
			printf("%d ", ans);
		}
		
	}
	
	return 0;
}

问题B：雀斑
问题描述：在迪克·范戴克 (Dick Van Dyke) 节目的一集中，小里奇 (Richie) 将父亲背上的雀斑连接起来，形成了自由钟的照片。唉，其中一个雀斑原来是疤痕，所以他的里普利的订婚失败了。
将 Dick 的背部视为在不同 (x,y) 位置有雀斑的平面。你的工作是告诉 Richie 如何连接点，以尽量减少使用的墨水量。里奇通过在对之间画直线来连接点，可能会在线之间提起笔。当 Richie 完成后，必须有一系列从任何雀斑到任何其他雀斑的连接线。

  • 输入
第一行包含 0 < n <= 100，即 Dick 背上雀斑的数量。对于每个雀斑，后面跟着一条线；以下每一行包含两个实数，表示雀斑的 (x,y) 坐标。
  • 输出
您的程序将一个实数打印到两个小数位：可以连接所有雀斑的墨水线的最小总长度。
  • 样例输入
3
2723.62 7940.81
8242.67 11395.00
4935.54 6761.32
9
10519.52 11593.66
12102.35 2453.15
7235.61 10010.83
211.13 4283.23
5135.06 1287.85
2337.48 2075.61
6279.72 13928.13
65.79 1677.86
5324.26 125.56
0
  • 样例输出
8199.56
32713.73

这题同样是稠密图，所以使用P算法：

#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxv = 110;//表示最多100个村庄
const double INF = 1000000000;//无穷大
int n, m;
double G[maxv][maxv];
int flag[maxv][maxv];
double x[maxv], y[maxv];
double d[maxv];
int vis[maxv];
double prim()
{
	fill(d, d + maxv, INF);
	fill(vis, vis + maxv, 0);
	d[1] = 0;
	double ans = 0;
	//首先找到距离集合S最小的点u以及距离d[u]
	for (int i = 1; i <=n; i++)
	{
		int u = -1,MIN = INF;
		for (int j = 1; j <= n; j++)
		{
			if (vis[j] == 0 && d[j] < MIN)
			{
				u = j;
				MIN = d[j];
			}
				
		}
		if (u == -1) return -1;
		vis[u] = 1;
		ans += d[u];
		//printf("!!!\n");
		for (int v = 1; v <= n; v++)
		{
			if (vis[v] == 0 && G[u][v] != INF && G[u][v] < d[v])
				d[v] = G[u][v];
		}
	}
	return ans;

}
int main()
{
	int u, v, w;
	while (scanf("%d", &n) != EOF)
	{
		if (n == 0)
			break;
		else
		{
			fill(G[0], G[0] + maxv * maxv, INF);
			fill(flag[0], flag[0] + maxv * maxv, 0.0);
			for (int i = 1; i <= n; i++)
			{
				scanf("%lf%lf",&x[i],&y[i]);//注意double类型输入要用%lf
			}
			for (int i = 1; i <= n; i++)
			{
				for(int j=1;j<=n;j++)
				{ 
					if (flag[i][j]==0)
					{
						G[i][j] = sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
						flag[i][j] = 1;
						//printf("%f\n",G[i][j]);
					}
				}
			}
			double ans = prim();
			printf("%.2f\n", ans);
		}		
	}	
	return 0;
}

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

  • 输入
测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M (N, M < =100 )；随后的 N 行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。
  • 输出
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“?”。
  • 样例输入
3 4
1 2 1
2 3 2
3 4 3
2 4
1 2 1
3 4 2
0 5
  • 样例输出
6
?

不能保证畅通即ans=-1，这题用K算法更加直观一些。

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxv = 110;//表示最多100个村庄
const int INF = 1000000000;//无穷大
int n, m, G[maxv][maxv];
int d[maxv];
int vis[maxv];
int prim()
{
	fill(d, d + maxv, INF);
	fill(vis, vis + maxv, 0);
	d[1] = 0;
	int ans = 0;
	//首先找到距离集合S最小的点u以及距离d[u]
	for (int i = 1; i <= m; i++)
	{
		int u = -1, MIN = INF;
		for (int j = 1; j <= m; j++)
		{
			if (vis[j] == 0 && d[j] < MIN)
			{
				u = j;
				MIN = d[j];
			}

		}
		if (u == -1) return -1;
		vis[u] = 1;
		ans += d[u];
		for (int v = 1; v <= m; v++)
		{
			if (vis[v] == 0 && G[u][v] != INF && G[u][v] < d[v])
				d[v] = G[u][v];
		}
	}
	return ans;

}
int main()
{
	int u, v, w;
	while (scanf("%d", &n) != EOF)
	{
		if (n == 0)
		{
			break;
		}			
		else
		{
			scanf("%d",&m);//村庄数目m
			fill(G[0], G[0] + maxv * maxv, INF);
			for (int i = 1; i <= n; i++)
			{
				scanf("%d%d%d", &u, &v, &w);
				G[u][v] = G[v][u] = w;
			}
			int ans = prim();
			if (ans != -1)
				printf("%d\n", ans);
			else
				printf("?\n");
		}

	}

	return 0;
}

问题 D: 继续畅通工程
问题描述：省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。

  • 输入
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。
当N为0时输入结束。
  • 输出
每个测试用例的输出占一行，输出全省畅通需要的最低成本。
  • 样例输入
4
1 2 1 1
1 3 6 0
1 4 2 1
2 3 3 0
2 4 5 0
3 4 4 0
3
1 2 1 1
2 3 2 1
1 3 1 0
0
  • 样例输出
3
0

这题用K算法比较直观，一定要注意下标！!，一个是sort函数的下标，一个是循环的下标
方法1：

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxv = 110;//表示最多100个村庄
const int maxe = 10010;
struct edge {
	int u;
	int v;
	int cost;
	int flag;//=1表示已建，=0表示未建
}E[maxe];
bool cmp(edge a, edge b)
{
	
	return a.cost < b.cost;
}
int father[maxv];
int findFather(int x)
{
	int a = x;
	while (x != father[x])
	{
		x = father[x];
	}
	int z = a;
	while (a != father[a])
	{
		father[z] = x;
		a = father[a];
		z = a;
		
	}
	return x;
}
int kruskal(int n, int m)
{
	int ans = 0, Num_Edge = 0;
	for (int i = 1; i <=n; i++)//n个点
	{
		father[i] = i;
	}//初始化
	//排序从低向高	

	sort(E+1, E +1+ m, cmp);
	for (int i = 1; i <= m; i++)//m条边
	{
		int faU = findFather(E[i].u);
		int faV = findFather(E[i].v);
		if (faU != faV)
		{
			father[faU] = faV;
			ans += E[i].cost;
			Num_Edge++;
			if (Num_Edge == n - 1)
				break;
		}
	}
	if (Num_Edge != n-1) return -1;
	else return ans;
}

int main()
{
	int n;
	int m;
	while (scanf("%d", &n) != EOF)
	{
		if (n == 0)
			break;
		else
		{
			 m = n * (n - 1) / 2;
			for (int i = 1; i <=m ; i++)
			{
				scanf("%d%d%d%d", &E[i].u, &E[i].v, &E[i].cost, &E[i].flag);
				if (E[i].flag == 1)
					E[i].cost = 0;
			}
		}
		int ans = kruskal(n, m);
		printf("%d\n",ans);
	}	
	return 0;
}

方法2：
还是方法一简单一点，但是不好想。

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxv = 110;//表示最多100个村庄
const int maxe = 10010;
struct edge {
	int u;
	int v;
	int cost;
	int flag;//=1表示已建，=0表示未建
}E[maxe];
bool cmp(edge a, edge b)
{
	
	return a.cost < b.cost;
}
int father[maxv];
int findFather(int x)
{
	int a = x;
	while (x != father[x])
	{
		x = father[x];
	}
	int z = a;
	while (a != father[a])
	{
		father[z] = x;
		a = father[a];
		z = a;
		
	}
	return x;
}
int kruskal(int n, int m)
{
	int ans = 0, Num_Edge = 0;
	for (int i = 1; i <=n; i++)//n个点
	{
		father[i] = i;
	}//初始化
	
	//首先让flag=1的点连通起来
	for (int i = 1; i <= m; i++)//m条边
	{
		if (E[i].flag == 1)
		{
			int faU = findFather(E[i].u);
			int faV = findFather(E[i].v);
			if (faU != faV)
			{
				father[faU] = faV;
				Num_Edge++;
			}
		}
	}

	sort(E+1, E +1+ m, cmp);
	for (int i = 1; i <= m; i++)//m条边
	{
		int faU = findFather(E[i].u);
		int faV = findFather(E[i].v);
		if (faU != faV)
		{
			father[faU] = faV;
			ans += E[i].cost;
			Num_Edge++;
			if (Num_Edge == n - 1)
				break;
		}
	}
	if (Num_Edge != n-1) return -1;
	else return ans;
}

int main()
{
	int n;
	int m;
	while (scanf("%d", &n) != EOF)
	{
		if (n == 0)
			break;
		else
		{
			 m = n * (n - 1) / 2;
			for (int i = 1; i <=m ; i++)
			{
				scanf("%d%d%d%d", &E[i].u, &E[i].v, &E[i].cost, &E[i].flag);
			}
		}
		int ans = kruskal(n, m);
		printf("%d\n",ans);
	}	
	return 0;
}

问题 E: Jungle Roads
问题描述：热带岛屿拉格里山的长老有问题。几年前，大量外援资金被用于修建村庄之间的额外道路。但是丛林无情地超越道路，因此大型道路网络的维护成本太高。长老议会必须选择停止维护一些道路。左上方的地图显示了所有正在使用的道路以及每月维护这些道路的成本（以 aacms 为单位）。当然，即使路线不像以前那么短，也需要通过某种方式在维护的道路上到达所有村庄。首席长老想告诉长老委员会，他们每个月可以在 aacms 上花费的最少金额来维护连接所有村庄的道路。在上面的地图中，村庄被标记为 A 到 I。右边的地图显示了可以最便宜地维护的道路，每月 216 aacms。你的任务是编写一个程序来解决这些问题。

  • 输入
输入由1到100个数据集组成，最后一行只包含0。 每个数据集以一行开始，只包含一个数字n，它是村庄的数量，1 < n < 27，村庄被标记字母表的前 n 个字母大写。每个数据集都由 n-1 行完成，这些行以字母顺序以村庄标签开头。最后一个村庄没有线路。一个村庄的每条线都以村庄标签开始，然后是从这个村庄到字母表中带有标签的村庄的道路数量 k。如果 k 大于 0，则该行继续包含 k 条道路中每条道路的数据。每条道路的数据是道路另一端的村庄标签，然后是道路的每月维护成本（以 aacms 为单位）。维护成本将是小于 100 的正整数。行中的所有数据字段都由单个空格分隔。公路网将始终允许在所有村庄之间通行。该网络的道路永远不会超过 75 条。没有一个村庄有超过 15 条通往其他村庄的道路（字母表中的之前或之后）。在下面的示例输入中，第一个数据集与上面的地图一致。
  • 输出
每个数据集的每行输出一个整数：维护连接所有村庄的道路系统的每月最低成本（以 aacms 为单位）。警告：检查每组可能的道路的蛮力解决方案不会在一分钟的时间限制内完成。
  • 样例输入
3
A 1 B 42
B 1 C 87
6
A 2 B 13 E 55
B 1 C 1
C 1 D 20
D 1 E 4
E 1 F 76
0
  • 样例输出
129
114

这题我改了一个小时！发现是输入输出的错误！
还有要注意结构体数组E的大小取决于边的个数，其他没什么啦

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxv = 30;
const int INF = 1000000000;
struct edge {
	int u;
	int v;
	int cost;	
}E[900];
int n, m, k;
bool cmp(edge a, edge b)
{	
	return a.cost < b.cost;
}
int father[30];
int findFather(int x)
{
	int a = x;
	while (x != father[x])
	{
		x = father[x];
	}
	int z = a;
	while (a != father[a])
	{
		father[z] = x;
		a = father[a];
		z = a;		
	}
	return x;
}
int kruskal()
{
	int ans = 0, Num_Edge = 0;
	for (int i = 1; i <=n; i++)//n个点
	{
		father[i] = i;
	}//初始化
	sort(E, E+m, cmp);
	for (int i = 0; i < m; i++)//m条边
	{
		int faU = findFather(E[i].u);
		int faV = findFather(E[i].v);
		if (faU != faV)
		{
			father[faU] = faV;
			ans += E[i].cost;
			Num_Edge++;
			if (Num_Edge == n - 1)
				break;
		}
	}
	if (Num_Edge != n-1) return -1;
	else return ans;
}

int main()
{	
	char u[3], v[3];
	int w;
	while (scanf("%d", &n) != EOF)
	{		
		if (n == 0)
			break;
		m = 0;
		for (int i = 1; i <= n - 1; i++)//一共n-1个地点
		{
			scanf("%s %d",u,&k);				
			while(k--)
			{
				scanf("%s%d", v, &w);				
				E[m].u = u[0] - 'A' + 1;
				E[m].v = v[0] - 'A' + 1;
				E[m].cost = w;						
				m++;
			}
		}
		int ans = kruskal();
		printf("%d\n", ans);		
	}	
	return 0;
}
susuate
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
跟左神一起练算法（图，拓扑排序，最小生成树算法）
weixin_43767691的博客
12-07 230
图？ 无向图，有向图 怎么描述一个图？ 邻接表法，邻接矩阵法 有向图，和无向图可以统一为有向图 无论是有向图还是无向图都可以按照有向图 进行表达 邻接表法： 邻接表法，和邻接矩阵法是最经典的两种表示方法，实际上还有很多的表示方法 拓扑排序 给你一张图 举个例子，我们的编译器在编一个个文件的时候就是按照拓扑排序来进行的 假如说编译B文件要先编译E,D文件，编译C文件需要编译D文件编译A文件...
P 算法与 K 算法
Practitioner
10-21 684
P 算法和 K 算法主要用来解决最小生成树问题，即：不破坏连通性删掉某些边，使得整体的权重最小。5）如果不会，要当前边，将该边的指向点加入到被选取的点中，重复2）4）如果会，不要当前边，继续考察剩下解锁的边中最小的边，重复3）3）如果当前的边进入最小生成树的集合中不会形成环，就要当前边。4）如果当前的边进入最小生成树的集合中会形成环，就不要当前边。2）某个点加入到被选取的点中后，解锁这个点出发的所有新的边。3）在所有解锁的边中选最小的边，然后看看这个边会不会形成环。1）可以从任意节点出发来寻找最小生成树。
最小生成树问题——小题三则
Mr_dimple的博客
03-29 562
文章目录1、新的开始题意：分析：Code：2、北极通讯网络题意：分析：Code：3、走廊泼水节题意：分析：Code： 1、新的开始 题意： 一共 nnn 口矿井，为保证电力的供应有两种策略： 在矿井 iii 上建立一个发电站，费用为 viv_ivi​（发电站的输出功率可以供给任意多个矿井）。 将这口矿井 iii 与另外的已经有电力供应的矿井 jjj 之间建立电网，费用为 pijp_{ij}pij​。 求保证所有矿井电力供应的最小花费方案。 分析： 如果只采取第二种策略，那么保证电力供应，也就是使得所有
最小生成树（K和P算法）
qq_45599754的博客
10-24 609
图的最小生成树
一张图带你看完图论第二章（包含定义、定理、公式、推导证明和例题）
mingrisanyang的博客
05-23 2137
包含第二章全部考点~没提到就是不考~ 树的定义 连通的无圈图 无圈图称为森林 树与森林都是简单图（非简单一定有圈-自环、重边） 都是偶图（无奇圈） 森林（n,m）里有K颗树，则m=n-k 森林里k对奇点--k条边不重的路，G的边集是这些路的并 归纳法证明 树的描述 树叶：度数=1分支点：度数>1 非平凡树至少有两片叶子 中心 点v离心率e(v) 从v出发最...
0025算法笔记——【贪心算法】最小生成树问题
热门推荐
liufeng_king的专栏
03-29 1万+
1、问题描述      设G =(V,E)是无向连通带权图，即一个网络。E中每条边(v,w)的权为c[v][w]。如果G的子图G’是一棵包含G的所有顶点的树，则称G’为G的生成树。生成树上各边权的总和称为该生成树的耗费。在G的所有生成树中，耗费最小的生成树称为G的最小生成树。      网络的最小生成树在实际中有广泛应用。例如，在设计通信网络时，用图的顶点表示城市，用边(v,w)的权c[v][
mariadb-10.5.10-rhel-7-x86_64-rpms.tar
05-28
mariadb-10.5.10-rhel-7-x86_64-rpms.tar
modelsim-10.5-win64-se安装软件+安装说明.zip
03-23
modelsim-10.5-win64-se安装软件+安装说明,支持 win7（64位），win8，win10系统；不支持XP，win7（32位）系统； 安装注意事项： 1、软件安装包路径和安装路径都不能有中文； 2、安装之前关闭电脑所有杀毒软件和...
ArcGIS Server10.5系列一：安装和配置-附件资源
03-02
ArcGIS Server10.5系列一：安装和配置-附件资源
edb-as10-server-10.5.12-1-windows-x64
11-23
EnterpriseDB是PostgreSQL的一个分支，在PostgreSQL基础上，针对企业级应用进行了专门的优化，同时，增加了一系列如动态 性能调优（DynaTune）、EDB Loader、高效批量SQL处理等高级特性；在众多功能亮点中，...
最小生成树算法之Prim算法
09-03
主要讲解了普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树,需要的朋友可以参考下
postgresql-10.5-2-windows-x64.exe
09-10
postgresql-10.5-2 postgresql-10.5-2-windows-x64.exe postgresql_10.5
Kruskal最小生成树边权相同的情况
xuzhankang的博客
12-09 2830
平时我们在利用Kruskal算法和优先队列解决最小生成树问题时，图的每个边权一般不相同。但要是有两个边权相同的边，这两个边的优先级怎么处理？ 答案是再结构体中再设置一个变量。 例如：要是规定两个相同边权的边谁先进队列谁的优先级就高，则结点设置一个时间变量，具体样例代码如下： struct NodeInfo { int from; int to; int weight; int time;//设置时间是为了如果边权相同，先进队列的优先级高 /**************
判断最小生成树是否唯一
weixin_30535565的博客
10-24 9892
我们知道在构造最小生成树的时候有可能会选择不同的边，这样构造的最小生成树不相同，但是最小生成树的权是唯一的！ 毫无疑问，无向图中存在相同权值的边是最小生成树不唯一的必要条件（但不是充分条件）。正因为如此，如果无向图中各边的权值都不相同，那么在用Kruskal算法构造最小生成树时，选择的方案是唯一的。 这里给出判定最小生成树唯一的算法思路： 1.对图中的每一条边，扫描其他边，如果存在...
最小生成树matlab求解
Planck_meteora的博客
03-07 7153
数学建模：最小生成树
简述Prim算法和Kruskal算法的相同与不同
StevenDouglas的博客
06-13 6850
学完离散数学和数据结构中图的最小生成树算法，对两种经典算法普利姆算法和克鲁斯卡尔算法有一点自己的认识。 Prim普利姆算法：在总的边集合-顶点集合A中，添加与A中顶点相邻的且边权值最小的顶点进入A。算法实现需要两个数组，一个记录与当前顶点集合A相邻的边的值，另一个记录到达 顶点总集合-A中的顶点 的顶点序号。时间复杂度O(n2)，n为顶点数 Kruskal克鲁斯卡尔算法：按权值大小排列，由小到大依次加入边，若产生回路则舍弃该边，直到所有顶点都可达。算法实现需要两个数组，第一个数组是二维的，将边的起点/终
图的最小生成树算法
GailyYelp的博客
03-20 933
目录 图的最小生成树算法之Prim算法简介 Prim算法举例及其详解 Prim代码块 图的最小生成树算法之Kruskal算法简介 Kruskal算法举例及其详解 Kruskal代码块 图的最小生成树算法之Prim算法简介1、生成树 　如果连通图G的一个子图是一棵包含G的所有顶点的树，则该子图称为G的生成树(SpanningTree)。 　生成树是连通图的包含图中的所有顶点的极小连
图论基础知识总结
欢迎订阅 -- 小源笔迹
07-18 6962
图是由节点和连接节点之间的边组成的，与连线的长度，节点的位置没有关系。一个图是一个三元组，其中V是一个非空的节点集合，E是边集合，F是从边集合E到节点序偶(无序偶或有序偶)集合上的函数。若图中边总是两个节点的关联，则图可简记为G=。树可以是空树但图不能是空图。图的结点集不能为空但边集可以为空。**无向图：**若图中所有边都是无向边，则图是无向图； **有向图：**若所有边都是有向边，则图是有向图； **混合图：**若图中既有无向边又有无向边则图为混合图； **多重图...
算法与数据结构—第七章、图相关习题及解析
weixin_56618945的博客
05-12 3735
1.以下关于图的叙述中，正确的是（CF. ）。 A.强连通有向图的任何顶点到其他所有顶点都有弧。 B.图的任意顶点的入度等于出度。 C.有向完全图一定是强连通有向图。 D.有向图的边集的子集和顶点集的子集可构成原有向图的子图。 E.图与树的区别在于图的边数大于等于顶点数 F.无向图的连通分量是指无向图中的极大连通子图。 解答：CF. A.强连通有向图的任何顶点到其他所有顶点都有路径（概念和定义！) B.在有向图中，所有顶点的入度之和是所有顶点出度之和的1倍。 由于每条弧必然连接两个顶点，也对应..
params.append(3); //行数 params.append(4); //列数 //表格对象 QAxObject* datatable = tables->querySubObject("Add(QAxObject*, int, int, QVariant&, QVariant&)", params); datatable->setProperty("Style", "网格型"); //设置表头 QAxObject* rangeTitle = datatable->querySubObject("Cell(int, int)", 1, 1)->querySubObject("Range"); rangeTitle->querySubObject("ParagraphFormat")->setProperty("Alignment", "wdAlignParagraphCenter"); rangeTitle->querySubObject("Font")->setProperty("Size", 10.5); rangeTitle->dynamicCall("SetText(QString)", QStringLiteral("序号")); rangeTitle = datatable->querySubObject("Cell(int, int)", 1, 2)->querySubObject("Range"); rangeTitle->querySubObject("ParagraphFormat")->setProperty("Alignment", "wdAlignParagraphCenter"); rangeTitle->querySubObject("Font")->setProperty("Size", 10.5); rangeTitle->dynamicCall("SetText(QString)", QStringLiteral("测量值")); rangeTitle = datatable->querySubObject("Cell(int, int)", 1, 3)->querySubObject("Range"); rangeTitle->querySubObject("ParagraphFormat")->setProperty("Alignment", "wdAlignParagraphCenter"); rangeTitle->querySubObject("Font")->setProperty("Size", 10.5); rangeTitle->dynamicCall("SetText(QString)", QStringLiteral("理论值"));帮我改成六列五行，表头分别是：序号、孔深（m）、倾角、方位角、上下偏差、左右偏差
最新发布
07-22
rangeTitle->querySubObject("Font")->setProperty("Size", 10.5); rangeTitle->dynamicCall("SetText(QString)", QStringLiteral("序号")); rangeTitle = datatable->querySubObject("Cell(int, int)", 1, 2)->...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值