图的四大算法区别及适用范围

已于 2025-03-24 14:08:18 修改
阅读量2.1k 收藏 56
点赞数 46
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 算法 数据结构 图论
于 2025-03-23 16:04:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83210553/article/details/146456053

一、普里姆(Prim)

1.1 算法思想

        对于图中的若干个顶点和若干条边，优先选择加入到已连通图中花费代价最小的点，又称为加点法。最后结果：生成最小生成树，获得最小连通图。

1.2 图例效果如下

图片节选自ZGULZ

1.3 适用题型

1.4 代码

① 结构体声明

重点是想象出辅助数组的作用，以及这个过程中辅助数组需要进行的操作

Closedge是用来记录顶点连接到图中的信息，ajdvex为和图中的哪个顶点相连接，lowcost为连接的最小花费，即无向网中的边的权值。

typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

typedef struct{
	char ajdvex; //指向该点连接图中最短路径的点 
	int lowcost;
}Closedge;
② 创建无向网
int LocateVex(AMGraph G,char v){  //获取指定顶点的下角标
	for(int i = 0;i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateUDN(AMGraph &G){  //创建无向图图
	char v1,v2;
	int i,j,w;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0;i < G.vexnum;i++){
		cin >> G.vex[i];
	}
	for(i = 0;i < G.vexnum;i++){
		for(int j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT; 
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = G.arc[j][i] = w;
	}
}

③ Prim算法实现

Min()用于获取记录的辅助数组中需要花费最小的点，若该顶点已经连接到图中，则将lowcost = 0

int Min(AMGraph G){  //获取剩余顶点中连接到图中的最小代价顶点
	int index = -1,min = MAX_INT;
	 for(int i = 0;i < G.vexnum;i++){
	 	if(min > closedge[i].lowcost && closedge[i].lowcost != 0){
	 		min = closedge[i].lowcost;
	 		index = i;
		 }
	 }
	 return index;
}

void MinSpanTree_Prim(AMGraph G,char v){  //Prim算法实现
	int k = LocateVex(G,v);
	closedge[k].lowcost = 0;
	cout << G.vex[k] << " " << closedge[k].lowcost<< endl;
	for(int i = 0;i < G.vexnum;i++){
		if(i != k){
			closedge[i].ajdvex = G.vex[k];
			closedge[i].lowcost = G.arc[k][i];
		}
		
	}
	for(int i = 1;i < G.vexnum;i++){
		k = Min(G);
		cout << closedge[k].ajdvex << "->" << G.vex[k] << " " << closedge[k].lowcost << endl;
		closedge[k].lowcost = 0;
		for(int j = 0;j < G.vexnum;j++){
			if(closedge[j].lowcost > G.arc[k][j]){
				closedge[j].lowcost = G.arc[k][j];
				closedge[j].ajdvex = G.vex[k];
			}
		}
	}
}
④ 全部代码
#include<iostream>
using namespace std;
#define MVNum 100
#define MAX_INT 1000000007
typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

typedef struct{
	char ajdvex; //指向该点连接图中最短路径的点 
	int lowcost;
}Closedge;

Closedge closedge[MVNum];

int LocateVex(AMGraph G,char v){
	for(int i = 0;i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateUDN(AMGraph &G){
	char v1,v2;
	int i,j,w;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0;i < G.vexnum;i++){
		cin >> G.vex[i];
	}
	for(i = 0;i < G.vexnum;i++){
		for(int j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT; 
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = G.arc[j][i] = w;
	}
}

int Min(AMGraph G){
	int index = -1,min = MAX_INT;
	 for(int i = 0;i < G.vexnum;i++){
	 	if(min > closedge[i].lowcost && closedge[i].lowcost != 0){
	 		min = closedge[i].lowcost;
	 		index = i;
		 }
	 }
	 return index;
}

void MinSpanTree_Prim(AMGraph G,char v){
	int k = LocateVex(G,v);
	closedge[k].lowcost = 0;
	cout << G.vex[k] << " " << closedge[k].lowcost<< endl;
	for(int i = 0;i < G.vexnum;i++){
		if(i != k){
			closedge[i].ajdvex = G.vex[k];
			closedge[i].lowcost = G.arc[k][i];
		}
		
	}
	for(int i = 1;i < G.vexnum;i++){
		k = Min(G);
		cout << closedge[k].ajdvex << "->" << G.vex[k] << " " << closedge[k].lowcost << endl;
		closedge[k].lowcost = 0;
		for(int j = 0;j < G.vexnum;j++){
			if(closedge[j].lowcost > G.arc[k][j]){
				closedge[j].lowcost = G.arc[k][j];
				closedge[j].ajdvex = G.vex[k];
			}
		}
	}
}

void PrintG(AMGraph G){
	for(int i = 0 ;i < G.vexnum;i++){
		for(int j = 0;j < G.vexnum;j++){
			cout << G.arc[i][j] << " ";
		}
		cout << endl;
	}
}
int main(){
	AMGraph G;
	char v;
	CreateUDN(G);
	cout << "请输入开始的结点符号：";
	cin >> v;
	//PrintG(G);
	MinSpanTree_Prim(G,v);	
}

1.5 测试数据

6 10
1 2 3 4 5 6
1 2 6
1 3 1
1 4 5
2 3 5
2 5 3 
3 4 5
3 5 6
3 6 4
4 6 2
5 6 6

1

二、克鲁斯卡尔(Kruskal)

2.1 算法思想

        通过每次最小边相连，同时保证是最小连通子图，不断更新最小连通子图，不断让最小连通子图相连，从而获取最后的最小连通子图，即最小生成树。

这里让不同的最小连通连通子图相连，可以保证不会构成回路。该算法不好想的地方在于最小连通子图如何进行判别，该算法适用一个极为巧妙的方法，起初初始化VexSet数组，并赋不同的值，标记是不同的连通子图。

for(int i = 0;i < G.vexnum;i++){
		VexSet[i] = i;  //这里赋值下标，赋值什么都行，不同即可
	}

如果顶点G.vex[0]和顶点G.vex[1]相连，则让二者的VexSet[0] == VexSet[1]来标记二者属于同一个最小连通子图。

2.2 图例实现过程

2.3 适用题型

最小生成树，花费最小代价连通全部顶点

例题如下：

2.4 代码

① 创建结构体

重点是想象出辅助数组的作用，以及这个过程中辅助数组需要进行的操作

typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

typedef struct{
	char Head; //起点
	char Tail; //终点
	int lowcost; //边的权值
}Edge;

int VexSet[MVNum];  //用来辨别是否同属一个最小连通子图
Edge edge[MVNum];
② 创建无向网

int LocateVex(AMGraph G,char v){
	for(int i = 0;i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateUDN(AMGraph &G){
	char v1,v2;
	int i,j,w;
	cin >> G.vexnum >> G.arcnum;
	for(int i = 0;i < G.vexnum;i++){
		cin >> G.vex[i];
	}
	for(int i = 0;i < G.vexnum;i++){
		for(int j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT;
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		edge[k].Head = v1;
		edge[k].Tail = v2;
		edge[k].lowcost = w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = G.arc[j][i] = w;	
	}	
}
③Kruskal算法实现

精髓在于对于VexSet[]的处置上，详细见注释

这里先进行边权值的排序，如果连接后还是最小连通图则连接，会构成回路则跳过该边，说明该边两边顶点已相连。

void MinSpanTree_Kruskal(AMGraph G){
	int i,j,vs1,vs2;
    int res = 0; //生成最小生成树的最小花费 
	sort(edge,edge+G.arcnum,cmp);
	for(int i = 0;i < G.vexnum;i++){
		VexSet[i] = i;
	}
	for(int k = 0;k < G.vexnum;k++){
		i = LocateVex(G,edge[k].Head);
		j = LocateVex(G,edge[k].Tail);
		vs1 = VexSet[i];
		vs2 = VexSet[j];
		if(vs1 != vs2){  //判断是否从属同一个最小连通子图，不是一个图则进入
            res += edge[k].lowcost; 
			for(int m = 0;m < G.vexnum;m++){  //让该图的所有顶点标记都改成要加入的图的标记
				if(VexSet[m] == vs2) VexSet[m] = vs1;
			}
		}
	}
    cout << "最小花费为：" << res;	
}
④ 全部代码
#include<iostream>
#include<algorithm>
using namespace std;
#define MVNum 100
#define MAX_INT 1000000007

//Kruskal适合稀疏边的最小生成树

typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

typedef struct{
	char Head;
	char Tail;
	int lowcost;
}Edge;

Edge edge[MVNum];
int VexSet[MVNum]; //用来判断最小连通量 

bool cmp(Edge x,Edge y){
	return x.lowcost < y.lowcost;
}

int LocateVex(AMGraph G,char v){
	for(int i = 0;i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateUDN(AMGraph &G){
	int i,j,w;
	char v1,v2;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0;i < G.vexnum;i++){
		G.vex[i] = i+'1';
	}
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT;
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = G.arc[j][i] = w;
		edge[k].Head = v1;
		edge[k].Tail = v2;
		edge[k].lowcost = w;
	}
}

//克鲁斯卡尔算法 
void MinSpanTree_Kruskal(AMGraph G){
	int i,j,vs1,vs2;
	int res = 0; //生成最小生成树的最小花费 
	sort(edge,edge+G.arcnum,cmp);
	for(i = 0;i < G.vexnum;i++){
		VexSet[i] = i; //初始化辅助数组 
	}
	for(int k = 0;k < G.arcnum;k++){ //依次判断边是否进行连接，
		i = LocateVex(G,edge[k].Head); 
		j = LocateVex(G,edge[k].Tail);
		vs1 = VexSet[i]; 
		vs2 = VexSet[j];
		if(vs1 != vs2){  //若该边两边顶点已经连接，则该边不进行连接 
			res += edge[k].lowcost; 
			for(int m = 0;m < G.vexnum;m++){
				if(VexSet[m] == vs2) VexSet[m] = vs1;
			}
		} 
	}
	cout << "最小花费为：" << res;	
} 

int main(){
	AMGraph G;
	CreateUDN(G);
	MinSpanTree_Kruskal(G); 
}

2.5 测试数据

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

测试结果如下：

三、迪杰斯特拉(Dijkstra)

3.1 算法思想

不断更新距离某点的最短路径，每次加入距离指定顶点的距离最短的一个顶点，同时比较新加入的顶点作为中转顶点是否可以使得其他顶点距离指定顶点的距离更近，如果更近，则更新辅助数组中的距离数据

3.2 图例实现过程

3.3 适用题型

用于求最短路径 ，求指定顶点到剩余各顶点的最短路径。

3.4 代码

① 创建结构体

重点是想象出辅助数组的作用，以及这个过程中辅助数组需要进行的操作

需要用到三个辅助数组

S[]: 用来标记该顶点是否已加入

D[]: 用来记录距离指定顶点的最短距离

Path[]: 用来记录前一个顶点的位置

typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

//辅助数组 
bool S[MVNum];
int D[MVNum];
int Path[MVNum];

② 创建有向网

int LocateVex(AMGraph G,char v){
	for(int i = 0; i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateDN(AMGraph &G){
	int i,j,w;
	char v1,v2;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0;i < G.vexnum;i++){
		cin >> G.vex[i];
	}
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT;
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = w;
	}
}

③ Dijkstra算法实现

void ShortestPath_DIJ(AMGraph G,char v0){
	int k = LocateVex(G,v0);
	for(int i = 0;i < G.vexnum;i++){
		S[i] = false;
		D[i] = G.arc[k][i];
		if(D[i] < MAX_INT) Path[i] = k;
		else Path[i] = -1; 
	}
	D[k] = 0;
	S[k] = true;
	for(int i = 1;i < G.vexnum;i++){
		int min = MAX_INT;
		for(int j = 0;j < G.vexnum;j++){
			if(!S[j] && D[j] < min){
				min = D[j];
				k = j;
			}
		}
		S[k] = true;
		for(int j = 0;j < G.vexnum;j++){
			if(!S[j] && D[j] > D[k]+G.arc[k][j]){
				D[j] = D[k] + G.arc[k][j];
				Path[j] = k;
			}
		}
	}
}
④ 全部代码
#include<iostream>
using namespace std;
#define MVNum 100
#define MAX_INT 1000000007

typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

//辅助数组 
bool S[MVNum];
int D[MVNum];
int Path[MVNum];

int LocateVex(AMGraph G,char v){
	for(int i = 0; i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateDN(AMGraph &G){
	int i,j,w;
	char v1,v2;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0;i < G.vexnum;i++){
		cin >> G.vex[i];
	}
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT;
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = w;
	}
} 

void ShortestPath_DIJ(AMGraph G,char v0){
	int k = LocateVex(G,v0);
	for(int i = 0;i < G.vexnum;i++){
		S[i] = false;
		D[i] = G.arc[k][i];
		if(D[i] < MAX_INT) Path[i] = k;
		else Path[i] = -1; 
	}
	D[k] = 0;
	S[k] = true;
	for(int i = 1;i < G.vexnum;i++){
		int min = MAX_INT;
		for(int j = 0;j < G.vexnum;j++){
			if(!S[j] && D[j] < min){
				min = D[j];
				k = j;
			}
		}
		S[k] = true;
		for(int j = 0;j < G.vexnum;j++){
			if(!S[j] && D[j] > D[k]+G.arc[k][j]){
				D[j] = D[k] + G.arc[k][j];
				Path[j] = k;
			}
		}
	}
	
} 


void PrintShortestPath(AMGraph G){
	for(int i = 0;i < G.vexnum;i++){
		cout << G.vex[i] << "距离：" << D[i] << " 路径为："; 
		
		//输入最短路径的具体路径 
		int k = i;
		int res[MVNum];
		int len = 0;
		res[len] = k;
		while(Path[k] != -1){
			k = Path[k];
			len++; 
			res[len] = k;
		}
		while(len >= 0){
			cout << G.vex[res[len]] << " ";
			len--;
		}
		cout << endl;
		
	}
}



int main(){
	AMGraph G;
	char v;
	CreateDN(G);
	cout << "请输入开始结点：" ;
	cin >> v;
	ShortestPath_DIJ(G,v);
	PrintShortestPath(G);
	
}

3.5 测试数据

四、弗洛伊德(Floyd)

4.1 算法思想

起初各顶点只有简单的相连关系，然后进行n次遍历，依次选择某一个顶点作为中转点，如果该中转点的距离更近，则更新最短距离，同时记录该中转点。不断遍历中转点，使各距离逐渐逼近最短距离，使用了动态规划的思想实现。

4.2 图例实现过程

4.3 适用题型

适合任意顶点到任意顶点的最短距离

//迪杰斯特拉用于计算指定顶点到各顶点之间的最短距离 

//弗洛伊德算法用于计算各顶点到各顶点之间的最短距离

图中任意两顶点之间的最短距离，相当于把迪杰斯特拉求的东西，按照每个顶点开始再求一边。但时间复杂度达到了O(n3)

例题如下：

4.4 代码

① 结构体和辅助数组

重点是想象出辅助数组的作用，以及这个过程中辅助数组需要进行的操作

//弗洛伊德算法用于计算各顶点到各顶点之间的最短距离
//迪杰斯特拉用于计算指定顶点到各顶点之间的最短距离 
typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

//辅助数组 
int D[MVNum][MVNum];  
int Path[MVNum][MVNum];  //记录中转点

② 创建有向网

int LocateVex(AMGraph G,char v){
	for(int i = 0; i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateDN(AMGraph &G){
	int i,j,w;
	char v1,v2;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0;i < G.vexnum;i++){
		cin >> G.vex[i];
	}
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT;
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = w;
	}
}

③ Floyd算法实现

void Floyd(AMGraph G){
	int i,j;
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			D[i][j] = G.arc[i][j];
			Path[i][j] = -1;
		}
	}
	for(int k = 0;k < G.vexnum;k++){
		for(i = 0;i < G.vexnum;i++){
			for(j = 0;j < G.vexnum;j++){
				if(D[i][j] > D[i][k]+G.arc[k][j]){
					D[i][j] = D[i][k] + G.arc[k][j];
					Path[i][j] = k;
				}
			}
		}
	}
}
④ 全部代码
#include<iostream>
using namespace std;
#define MVNum 100
#define MAX_INT  1000000007

//弗洛伊德算法用于计算各顶点到各顶点之间的最短距离
//迪杰斯特拉用于计算指定顶点到各顶点之间的最短距离 

typedef struct{
	char vex[MVNum];
	int arc[MVNum][MVNum];
	int vexnum,arcnum;
}AMGraph;

//辅助数组 
int D[MVNum][MVNum];
int Path[MVNum][MVNum];//记录中转点 

int LocateVex(AMGraph G,char v){
	for(int i = 0;i < G.vexnum;i++){
		if(G.vex[i] == v) return i;
	}
	return -1;
}

void CreateUDN(AMGraph &G){
	int i,j,w;
	char v1,v2;
	for(i = 0;i < G.vexnum;i++){
		G.vex[i] = i+'0';
	} 
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			G.arc[i][j] = MAX_INT;
		}
	}
	for(int k = 0;k < G.arcnum;k++){
		cin >> v1 >> v2 >> w;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		G.arc[i][j] = G.arc[j][i] = w;
	}
}
void Floyd(AMGraph G){
	int i,j;
	for(i = 0;i < G.vexnum;i++){
		for(j = 0;j < G.vexnum;j++){
			D[i][j] = G.arc[i][j];
			Path[i][j] = -1;
		}
	}
	for(int k = 0;k < G.vexnum;k++){
		for(i = 0;i < G.vexnum;i++){
			for(j = 0;j < G.vexnum;j++){
				if(D[i][j] > D[i][k]+G.arc[k][j]){
					D[i][j] = D[i][k] + G.arc[k][j];
					Path[i][j] = k;
				}
			}
		}
	}
}

int Location(AMGraph G){
	int min = MAX_INT;
	int index = -1;
	for(int i = 0;i < G.vexnum;i++){
		int sum = 0;
		for(int j = 0;j < G.vexnum;j++){
			if(D[i][j] < MAX_INT){  //无向网时，这个不判断也行，题目保证了城市之间是连通的 
				sum += D[i][j];	
			}
		}
		if(min > sum){
			min = sum;
			index = i;
		}
	}
	cout << G.vex[index] << endl;	
}

int main(){
	int n,m;
	AMGraph G;
	while(cin >> n >> m){
		G.vexnum = n;
		G.arcnum = m;
		CreateUDN(G);
		Floyd(G);
		Location(G);
	}
	
}

4.5 测试数据

6 5
0 1 1
0 2 1
0 3 1
0 4 1
0 5 1
4 5
0 1 1
0 2 5
1 2 2
1 3 4
2 3 1

e
测试结果如下：

【数据结构|C语言版】四大排序（算法）
GUIQU的博客
06-30 1803
各位小伙伴大家好！上次小编给大家讲解了数据结构中的树、二叉树和堆，接下来我们讲解一下排序算法中的四大排序！
一文搞定推荐系统及算法
weixin_41593193的博客
03-12 1586
近年来，深度学习技术的快速发展，大大加速了人工智能在传统和互联网领域的商业化落地。现如今，人工智能的应用已如雨后春笋般渗透到我们衣食住行的方方面面。比如无人超市的面世、无人驾驶汽车的正式上路、智能手机刷脸识别模式、医疗图像技术等。 与此同时，面对时间的碎片化、信息的同质化/海量化、用户选择项的增多和用户耐心的减退，如何满足用户需求、拓展用户需求、驱动业务增长、优化行业生态等，成了各个行业亟待解决的问题。因此，个性化推荐系统便应运而生了。
图的经典四大算法-Prim和Kruskal,Dijkstra和Floyd算法
weizhifei1234的博客
04-07 8704
一.简介 这篇博文主要是讲解两种算法 一个是最小生成树算法(最小代价树) 里面包含了两种算法:Prim算法和Kruskal算法(PK算法)用于把图中的点全部连接起来 另一个是单源最短路径算法:Dijkstra算法和Floyd算法(简称DF二连算法)用于求解单源最短路径 二.算法简介 对于最小代价生成树的Prim、Kruskal算法，两种算法的主要核心思想是贪心算法。 Prim算法是从...
四种经典图算法(未debug版)
Liyizhi111的博客
03-16 516
胡搞
Kruskal（克鲁斯卡尔）算法 vs. Prim（普里姆）算法区别
最新发布
2301_81882590的博客
05-09 719
Kruskal算法和Prim算法都是用于求解最小生成树（MST）的经典算法，但它们在实现方式和适用场景上有所不同。Kruskal算法通过按边权值从小到大选择边，并避免形成环，适用于稀疏图，时间复杂度为O(ElogE)，主要来自排序操作。Prim算法则从某个顶点出发，逐步扩展最小权值的边，适用于稠密图，时间复杂度为O(ElogV)，使用优先队列优化。Kruskal算法不需要初始顶点，而Prim算法需要。选择算法时，稀疏图适合Kruskal，稠密图适合Prim。两者都能得到正确的最小生成树，但实现方式和适用场景
图解算法：四大查找算法
轻松的小希
03-13 3773
目录第一章 顺序查找算法1.1、算法介绍1.2、算法实现第二章 二分查找算法2.1、算法介绍2.2、算法实现第三章 插值查找算法3.1、算法介绍3.2、算法实现第四章 斐波那契查找4.1、算法介绍4.2、算法实现 项目地址：https://gitee.com/caochenlei/algorithms 第一章 顺序查找算法 1.1、算法介绍 顺序查找（Order Search）也称为线形查找，从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值num相比较，若相等则表示查找成功；若扫
图论算法——Prim算法和Kruskal算法
日积月累，天道酬勤
05-24 1401
引言 我们要学习的第一种计算最小生成树的算法，它每一步都会为一颗生长中的树添加一条边。 下面分析下算法思路 思路 一开始这棵树只有一个顶点，然后会向它添加V-1条边，每次总是将下一条连接树中的顶点与不在树中的顶点且权重最小的边加入树中。 每次当我们向(生成)树中添加了一条边之后，也向树中添加了一个顶点。要维护一个包含所有横切边的集合，就要将连接这个顶点和其他所有不在树中的顶点的边加入优先队列。要注...
数据结构——图
m0_73949658的博客
06-12 755
在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，我们称为AOV网( Activity On VertexNetwork)。若用DAG图（有向无环图）表示一个工程，其顶点表示活动，用有向边< V i , V j > 表示活动Vi必须先于活动Vj进行的这样一种关系。在AOV网中，活动Vi是活动Vj的直接前驱，活动Vj是活动Vi的直接后继，这种前驱和后继关系具有传递性，且任何活动Vi不能以它自己作为自己的前驱或后继。二、算法。
四大机器学习降维算法：PCA、LDA、LLE与Laplacian Eigenmaps的解析及其应用场景
03-11
文中提供了数学建模的具体步骤、优劣分析及其适用范围。 适合人群：对于机器学习算法有所涉猎的研究学者、数据科学家、软件开发者等需要深入了解各类降维工具的专业人士。 使用场景及目标：适用于那些面对大规模、...
Matlab 车辆配送路径规划问题 四大算法解决旅行商问题(TSP) CVRP CDVRP VRPTW tsp:旅行商问题，寻
09-17
而带距离、容量及时间窗约束的车辆路径规划（VRPTW）是更为复杂的问题，除了载重和距离的限制外，还加入了时间窗约束，即每个顾客都有一个特定的时间范围，在这个时间范围内需要完成服务。VRPTW的算法研究包括精确...
最短路四大算法证明以及分析（Floyd Dijkstra Bellman-ford SPFA）
Dch19990825的博客
01-29 855
此博文不具体给出其算法的代码，只对其中算法进行分并且给予证明 PS：这些算法我不用证明都是它是正确的（上世纪的数学家看着这些都不用证明，为啥，很简单的），但是我坚持重新证明一遍实际是为了加深印象，并且理解其中的道理和思想，这样在以后的运用中才能灵活运用，当然证明这些算法也 算法一：Floyd 算法，也是传说中的只用五行就可以解决的多源最短路径问题 采用邻接矩阵来储存图，时间复杂度为O（...
prim算法、kruskal算法和dijkstra算法
vavakavak的博客
07-15 1028
prim算法 prim算法用于寻找图中的最小生成树，总体思路如下： 开始时，从图中任取一个节点作为初始点，另作一“距离表”存放其他所有节点到已访问节点的直接距离，初始值即为到初始点的距离。 接着找出距离已访问节点集最近的节点，加入已访问节点。此时要用新节点和其他节点的距离来更新“距离表”中已访问节点集和各未访问节点的距离。 重复2中操作直到已访问节点集中的节点数量时全部为止。 void prim(const vector<vector<int>>& path, vect
最小生成树之克鲁斯卡尔算法和普里姆算法
热门推荐
青萍之末的博客
06-04 3万+
一、最小生成树简介   假设有一个很实际的问题：我们要在n个城市中建立一个通信网络，则连通这n个城市需要布置n-1一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？   于是我们就可以引入连通图来解决我们遇到的问题，n个城市就是图上的n个顶点，然后，边表示两个城市的通信线路，每条边上的权重就是我们搭建这条线路所需要的成本，所以现在我们有n个顶点的连通网可以建立不同的生成...
知识点四 图论：Prim算法 Kruskal算法 （最小生成树）
Authur_gyc
07-17 1293
解决的问题 这两个算法都是用来在加权连通图里搜索最小生成树。 也就是一个图有很多边，这些边有权值，然后我们要从这些边中找到这样一个边的集合，使得全部的顶点都是连通的，并且边的权值之和最小。 Prim(普里姆算法) 算法描述： 1).输入：一个加权连通图，其中顶点集合为V，边集合为E； 2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空； 3).重复下...
最小生成树(Prim算法和Kruskal算法)
weixin_44267007的博客
08-15 1348
最小生成树 ​ 本部分主要对图中一些关于连通性和最小生成树的概念进行学习和理解，之后对于建立最小生成树的两种算法进行学习和实现。 ​ 接下来主要对于无向图进行分析，有向图也是一样的分析方法。 文章目录最小生成树图的连通性以及生成树图的连通性判断最小生成树普里姆算法PrimPrimPrim克鲁斯卡尔算法KruskalKruskalKruskal 图的连通性以及生成树 ​ 首先对图连通性中一些定义进行阐释： 在无向图中，如果存在不连通的顶点，则该图称为非连通图。 非连通图的最大连通子图叫做连通分量。 若从无向
最小生成树（prim和kruskal）学习笔记
2403_85701606的博客
12-11 1680
有两个求最小生成树的算法，prim算法和kruskal算法。这两种算法都可以处理边权为负的情况，并且可以处理有负权回路的情况。接下来会分析一下两个算法的区别。
最小生成树算法
wanglianda2007的博客
01-05 1608
三种常见最小生成树算法原理。
程序员常用十种算法（6）— 普利姆算法（修路问题）
谁偷了我的月亮的博客
07-01 318
程序员常用十种算法（6）— 普利姆算法（修路问题） 在介绍普利姆算法之前先介绍一下最小生成树。 1. 最小生成树 最小生成树（Minimum Cost Spanning Tree）, 简称 MST。给定一个带权的无向连通图，如何选取一颗生成树，使树上所有边上权的总和为最小，这叫最小生成树： 1）N个顶点，一定有N-1条边 2）包含全部顶点 3）N-1条边都在图中 4）如下图例子所示 5）求最小生成树的主要算法是普利姆算法和克鲁斯卡尔算法。 2.普利姆算法介绍 普利姆（Prim）算法求最小生成树，也就是在包含
回溯算法详解：四大经典应用与4皇后问题实例
回溯算法是一种重要的搜索技术，它在解决复杂问题时通过系统性地探索解空间来寻找最优解，特别适用于那些解的数量巨大但通过特定规则可以减少搜索范围的问题。其核心在于构建一个解空间树，每个节点代表一个问题状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值