C/C++利用迪杰斯特拉最短路径算法，求解千万结点道路网最短路径

已于 2024-03-06 00:09:36 修改
阅读量288 收藏 4
点赞数 1
文章标签： 算法
于 2023-10-14 00:16:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazybobo1207/article/details/133819754
版权

《算法导论》dijkstra算法的图，怎么图是歪的？顺便治疗一下颈椎病，嘎嘎！

计算机程序很笨，一开始它看不到整个图，只能从起点开始，慢慢的探索周围的点，由近及远，所以它是一个广度优先搜索。

很自然的，程序刚开始，要把所有点的distance值（从起点到该点的距离）设置为无穷大，意味所有点都是不可达的状态。 然后，我们要把起点的distance值设置为0，并将起点放入一个集合（这个集合可以采用优先队列，队首元素就是distance值最小的那个结点）。接下来，程序进入循环，循环里面做3件事：

（1）从当前集合里找到distance值最小的点（队首元素），准备进行处理。

（2）更新这个点的所有邻接点的distance值，更新的条件是什么呢？假设这个点是A点，它的distance值是50（从起点到A点的距离值是50），它有一个邻接点是B点，此前B点的distance值是100（从起点到B点的距离值是100），又假设A到B的距离只有10，那么我们发现：经过A到达B，有一条比之前100更短的路径，即50+10=60，这时候将B的distance值更新为60，意味着我们找到了一条从起点到达B点的更短的路径。（将这个点的邻接点放入集合，这一个操作要不要，取决于集合是怎么定义的）

（3）将这个处理过的A点从集合中删除（队首元素出队）。

这个算法有两个关键的事情：一是这个集合里的点的个数是如何增减的，二是如何在这个集合里找到distance值最小的点。

做到这两件事不难，但是要保证程序运行效率，需要考虑一些事。

第一，找最小值，用什么方法？所有数据排序？这种排序的目的是“让全体数据有序”，但实际上我们不需要这种“有序”，我们只需要找到那个最小的值就行。用遍历一遍的方法，找到最小值？效率还是低了。最后我们用小根堆来找到最小值，C++里可以自己建堆、调整堆，但是，可以直接用优先队列，速度还要快一点，优先队列它也是用堆实现的。

第二，集合如何定义？这个集合里装的是未处理过的结点，还是待处理的结点？这两者是有区别的。

下面使用老美网站上的一个数据集来测试最短路径程序。网址是：9th DIMACS Implementation Challenge: Shortest Paths

直接使用比较大的道路数据集，1400多万结点，3400多万条边。

先用C++的map，将原始的边数据转为邻接矩阵（这个代码略），而且分多个文件存储，回头可以多线程读取文件，加快文件读取速度，点的数据也分为多个文件存储。

上图数据的解释：从点0到点2516544有一条路径，长度是2025米，从点0到点576739有一条路径，长度是2617米，从点0到点1520470有一条路径，长度是520，也就是说从点0出去有3条路径；然后，从点1到点524282有一条路径，长度是2359……

程序运行结果，读文件到内存1.4秒，找到一个点到其它1400多万个点的最短路径，大概用时1.6秒：

路径有点长，所以保存在一个path.txt文件中：

代码如下：

#include <vector>
#include <queue>
#include <thread>
#include <limits>
#include <iostream>
using namespace std;

#define THREADNUM 14
#define PINFINITY INT_MAX

class CVertex
{
public:
	int id;
	int distance;	//从源点到该点的距离
	int parent;     //记录最短路径经过的结点

public:
	CVertex(int _id = -1, int _distance = -1, int _parent = -1)
	{
		id = _id;
		distance = _distance;
		parent = _parent;
	}

	void operator=(const CVertex& vertex)
	{
		id = vertex.id;
		distance = vertex.distance;
		parent = vertex.parent;
	}

	bool operator<(const CVertex& vertex)
	{
		return this->distance < vertex.distance;
	}

	~CVertex()
	{

	}
};

class CVexIdAndDistance
{
public:
	int id;
	int distance;

public:
	CVexIdAndDistance(int _id = -1, int _distance = -1)
	{
		id = _id;
		distance = _distance;
	}

	bool operator==(const CVexIdAndDistance& vexIdAndDistance)
	{
		if (id == vexIdAndDistance.id && distance == vexIdAndDistance.distance)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	~CVexIdAndDistance()
	{

	}
};

class CEdge
{
public:
	int toVexId;
	int weight;

public:
	CEdge(int _toVexId = -1, int _weight = 0)
	{
		toVexId = _toVexId;
		weight = _weight;
	}
};

class Cmp
{
public:
	bool operator() (const CVexIdAndDistance& a, const CVexIdAndDistance& b)
	{
		return a.distance > b.distance;
	}
};

int GetVertexNumThread(const char* vertexInfoFilePath, int* vertexNumPerFile, int tid);
int GetEdgeNumThread(const char* edgeInfoFilePath, int* edgeNum, int tid);
int GetVertexAndEdgeInfoThread(const char* vertexInfoFilePath, const char* edgeInfoFilePath, CVertex* vertex, CEdge** edge, int tid);
int UpdateDistance(CVertex* vertex, priority_queue<CVexIdAndDistance, vector<CVexIdAndDistance>, Cmp>& priorityQueueForSort, const int* edgeNum, const CEdge* const* edge, int srcVexId, int dstVexId);
int GetPath(const CVertex* vertex, int srcVexId, int dstVexId);

char vertexInfoFilePath[50] = "e:\\USA-road-d.Central\\vertex";
char edgeInfoFilePath[50] = "e:\\USA-road-d.Central\\edge";
int totalVertexNum = 0;
int vertexNumPerThread = 0;

int main()
{
	clock_t c[10] = { 0 };
	c[0] = clock();

	cout << THREADNUM << "线程从文件读取点和边数据" << endl;

	int all_vertex_file_size = 0;
	long long int all_edge_file_size = 0;
	FILE* fp = NULL;

	for (int i = 0; i < THREADNUM; i++)
	{
		char vertexInfoFileName[50] = "";
		strcat_s(vertexInfoFileName, vertexInfoFilePath);
		char temp[5] = "";
		_itoa_s(i, temp, 10);
		strcat_s(vertexInfoFileName, temp);
		strcat_s(vertexInfoFileName, ".txt");

		fopen_s(&fp, vertexInfoFileName, "rb");
		if (fp == NULL)
			return -1;

		_fseeki64(fp, 0, SEEK_END);
		long long int filesize = _ftelli64(fp);
		all_vertex_file_size += filesize;

		if (fp != NULL)
			fclose(fp);

		char edgeInfoFileName[50] = "";
		strcat_s(edgeInfoFileName, edgeInfoFilePath);
		_itoa_s(i, temp, 10);
		strcat_s(edgeInfoFileName, temp);
		strcat_s(edgeInfoFileName, ".txt");

		fopen_s(&fp, edgeInfoFileName, "rb");
		if (fp == NULL)
			return -1;

		_fseeki64(fp, 0, SEEK_END);
		filesize = _ftelli64(fp);
		all_edge_file_size += filesize;

		if (fp != NULL)
			fclose(fp);
	}

	cout << "点文件大小:" << all_vertex_file_size / 1024.0 / 1024 / 1024 << " GB" << endl;
	cout << "边文件大小:" << all_edge_file_size / 1024.0 / 1024 / 1024 << " GB" << endl;

	int vertexNumPerFile[THREADNUM] = { 0 };

	thread td0[THREADNUM];

	for (int i = 0; i < THREADNUM; i++)
	{
		td0[i] = thread(&GetVertexNumThread, vertexInfoFilePath, vertexNumPerFile, i);
	}

	for (int i = 0; i < THREADNUM; i++)
	{
		td0[i].join();
	}

	for (int i = 0; i < THREADNUM; i++)
	{
		totalVertexNum += vertexNumPerFile[i];
	}

	vertexNumPerThread = int((totalVertexNum / 1000000) / THREADNUM) * 1000000;

	CVertex* vertex = new CVertex[totalVertexNum];
	int* edgeNum = new int[totalVertexNum];
	memset(edgeNum, -1, totalVertexNum);

	int totalEdgeNum = 0;
	int srcVexId = -1, dstVexId = -1;

	thread td1[THREADNUM];

	for (int i = 0; i < THREADNUM; i++)
	{
		td1[i] = thread(&GetEdgeNumThread, edgeInfoFilePath, edgeNum, i);
	}

	for (int i = 0; i < THREADNUM; i++)
	{
		td1[i].join();
	}

	for (int i = 0; i < totalVertexNum; i++)
	{
		totalEdgeNum += edgeNum[i];
	}

	CEdge** edge = new CEdge * [totalVertexNum];
	if (edge == NULL)
	{
		return -1;
	}

	for (int i = 0; i < totalVertexNum; i++)
	{
		edge[i] = NULL;
	}

	for (int i = 0; i < totalVertexNum; i++)
	{
		if (edgeNum[i] != 0)
		{
			edge[i] = new CEdge[edgeNum[i]];
			if (edge[i] == NULL)
			{
				return -1;
			}
		}
		else
			edge[i] = NULL;
	}

	thread td2[THREADNUM];

	for (int i = 0; i < THREADNUM; i++)
	{
		td2[i] = thread(&GetVertexAndEdgeInfoThread, vertexInfoFilePath, edgeInfoFilePath, vertex, edge, i);
	}

	for (int i = 0; i < THREADNUM; i++)
	{
		td2[i].join();
	}

	cout << "图中点数:" << totalVertexNum << endl;
	cout << "图中边数:" << totalEdgeNum << endl;

	c[1] = clock();
	cout << "用时:" << c[1] - c[0] << "毫秒" << endl;
	cout << "----------------------------------------" << endl;

	c[2] = clock();

	int maxOutDegree = 0;
	int imax = 0;
	for (int i = 0; i < totalVertexNum; i++)
	{
		if (edgeNum[i] > maxOutDegree)
		{
			maxOutDegree = edgeNum[i];
			imax = i;
		}
	}
	cout << "顶点" << imax << "具有最大出度:" << maxOutDegree << endl;

	c[3] = clock();
	cout << "用时:" << c[3] - c[2] << "毫秒" << endl;
	cout << "----------------------------------------" << endl;

	cout << "输入起点ID:";
	cin >> srcVexId;

	c[4] = clock();

	vertex[srcVexId].distance = 0;
	priority_queue<CVexIdAndDistance, vector<CVexIdAndDistance>, Cmp> priorityQueueForSort;
	priorityQueueForSort.push(CVexIdAndDistance(srcVexId, 0));

	UpdateDistance(vertex, priorityQueueForSort, edgeNum, edge, srcVexId, dstVexId);

	c[5] = clock();
	cout << "计算起点" << srcVexId << "到其它所有点的最短路径用时:" << c[5] - c[4] << "毫秒" << endl;
	cout << "----------------------------------------" << endl;

	while (true)
	{
		cout << "输入终点ID:";
		cin >> dstVexId;
		if (dstVexId == -1)
		{
			break;
		}
		c[6] = clock();
		GetPath(vertex, srcVexId, dstVexId);
		c[7] = clock();
		cout << "用时:" << c[7] - c[6] << "毫秒" << endl;
		cout << "----------------------------------------" << endl;
	}

	return 0;
}

int GetVertexNumThread(const char* vertexInfoFilePath, int* vertexNumPerFile, int tid)
{
	char vertexInfoFileName[50] = "";
	strcat_s(vertexInfoFileName, vertexInfoFilePath);
	char temp[5] = "";
	_itoa_s(tid, temp, 10);
	strcat_s(vertexInfoFileName, temp);
	strcat_s(vertexInfoFileName, ".txt");

	FILE* fp;
	fopen_s(&fp, vertexInfoFileName, "rb");
	if (fp == NULL)
		return -1;

	char* line = new char[100];

	while (!feof(fp))
	{
		fgets(line, 100, fp);
		vertexNumPerFile[tid]++;
	}
}

int GetEdgeNumThread(const char* edgeInfoFilePath, int* edgeNum, int tid)
{
	char edgeInfoFileName[50] = "";
	strcat_s(edgeInfoFileName, edgeInfoFilePath);
	char temp[5] = "";
	_itoa_s(tid, temp, 10);
	strcat_s(edgeInfoFileName, temp);
	strcat_s(edgeInfoFileName, ".txt");

	FILE* fp = NULL;
	fopen_s(&fp, edgeInfoFileName, "r");
	if (fp == NULL)
		return -1;

	char* line = new char[totalVertexNum * 2];
	int i, j;
	int lineIndex = 0;
	int tokenIndex = 0;

	while (!feof(fp))
	{
		fgets(line, totalVertexNum * 2, fp);

		tokenIndex = 0;
		i = 0;

		while (line[i] != '\0')
		{
			if (line[i] >= '0' && line[i] <= '9')
			{
				j = 0;
				while (line[i] >= '0' && line[i] <= '9')
				{
					i++;
				}
				tokenIndex++;
			}
			else
			{
				i++;
			}
		}

		edgeNum[vertexNumPerThread * tid + lineIndex] = tokenIndex / 2;
		lineIndex++;
	}
}

int GetVertexAndEdgeInfoThread(const char* vertexInfoFilePath, const char* edgeInfoFilePath, CVertex* vertex, CEdge** edge, int tid)
{
	char vertexInfoFileName[50] = "";
	strcat_s(vertexInfoFileName, vertexInfoFilePath);

	char temp[5] = "";
	_itoa_s(tid, temp, 10);
	strcat_s(vertexInfoFileName, temp);
	strcat_s(vertexInfoFileName, ".txt");

	FILE* fp = NULL;
	fopen_s(&fp, vertexInfoFileName, "rb");

	if (fp == NULL)
		return -1;

	char* line = new char[totalVertexNum * 2];
	char t[50];
	int tokenIndex = 0;

	while (!feof(fp))
	{
		fgets(line, totalVertexNum * 2, fp);
		int i = 0;
		int j;
		while (line[i] != '\0')
		{
			if (line[i] >= '0' && line[i] <= '9')
			{
				j = 0;
				while (line[i] >= '0' && line[i] <= '9')
				{
					t[j++] = line[i++];
				}
				t[j] = '\0';

				vertex[vertexNumPerThread * tid + tokenIndex].id = atoi(t);
				tokenIndex++;
			}
			else
			{
				i++;
			}
		}
	}

	if (tid < THREADNUM - 1)
	{
		for (int i = 0; i < vertexNumPerThread; i++)
		{
			vertex[vertexNumPerThread * tid + i].distance = PINFINITY;
		}
	}
	else
	{
		for (int i = 0; i < totalVertexNum - vertexNumPerThread * THREADNUM + vertexNumPerThread; i++)
		{
			vertex[vertexNumPerThread * tid + i].distance = PINFINITY;
		}
	}

	if (fp != NULL)
		fclose(fp);

	char edgeInfoFileName[50] = "";
	strcat_s(edgeInfoFileName, edgeInfoFilePath);
	_itoa_s(tid, temp, 10);
	strcat_s(edgeInfoFileName, temp);
	strcat_s(edgeInfoFileName, ".txt");
	fopen_s(&fp, edgeInfoFileName, "rb");
	if (fp == NULL)
		return -1;

	int i, j;
	int lineIndex = 0;
	tokenIndex = 0;

	while (!feof(fp))
	{
		fgets(line, totalVertexNum * 2, fp);
		tokenIndex = 0;
		i = 0;

		while (line[i] != '\0')
		{
			if (line[i] >= '0' && line[i] <= '9')
			{
				j = 0;
				while (line[i] >= '0' && line[i] <= '9')
				{
					t[j++] = line[i++];
				}
				t[j] = '\0';

				if (tokenIndex % 2 == 0)
				{
					edge[vertexNumPerThread * tid + lineIndex][tokenIndex / 2].toVexId = atoi(t);
				}
				else
				{
					edge[vertexNumPerThread * tid + lineIndex][tokenIndex / 2].weight = atoi(t);
				}

				tokenIndex++;
			}
			else
			{
				i++;
			}

		}

		lineIndex++;
	}

	if (fp != NULL)
		fclose(fp);

	return 0;
}


int UpdateDistance(CVertex* vertex, priority_queue<CVexIdAndDistance, vector<CVexIdAndDistance>, Cmp>& priorityQueueForSort, const int* edgeNum, const CEdge* const* edge, int srcVexId, int dstVexId)
{
	CVexIdAndDistance currentVertex;
	vector<CVexIdAndDistance>::iterator iter;

	while (true)
	{
		if (priorityQueueForSort.size() == 0)
		{
			break;
		}

		currentVertex = priorityQueueForSort.top();
		priorityQueueForSort.pop();

		for (int i = 0; i < edgeNum[currentVertex.id]; i++)
		{
			if (edgeNum[currentVertex.id] == 0)
			{
				continue;
			}

			int toVexId = edge[currentVertex.id][i].toVexId;

			if (currentVertex.distance + edge[currentVertex.id][i].weight < vertex[toVexId].distance)
			{
				vertex[toVexId].distance = currentVertex.distance + edge[currentVertex.id][i].weight;
				vertex[toVexId].parent = currentVertex.id;
				priorityQueueForSort.push(CVexIdAndDistance(toVexId, vertex[toVexId].distance));
			}
		}
	}
	return 0;
}

int GetPath(const CVertex* vertex, int srcVexId, int dstVexId)
{
	if (vertex[dstVexId].distance == PINFINITY)
	{
		cout << endl << "no path to the vertex " << dstVexId << endl;
		return -1;
	}

	int* path = new int[totalVertexNum];
	memset(path, -1, totalVertexNum);

	int i = 0;
	int tid = dstVexId;

	while (tid != -1)
	{
		path[i++] = tid;
		tid = vertex[tid].parent;
		if (tid == srcVexId)
		{
			break;
		}
	}

	path[i] = tid;

	for (int j = 0; j < (i + 1) / 2; j++)
	{
		int t = path[j];
		path[j] = path[i - j];
		path[i - j] = t;
	}

	FILE* fp = NULL;
	fopen_s(&fp, "e:\\path.txt", "w");
	if (fp == NULL)
		return -1;

	cout << "从起点" << srcVexId << "到终点" << dstVexId << "的最短路径长度=" << vertex[dstVexId].distance << endl;

	fprintf(fp, "起点%d到终点%d的最短路径: %d\n", srcVexId, dstVexId, vertex[dstVexId].distance);
	fprintf(fp, "最短路径一共经过%d个顶点（包括起点和终点）:\n", i + 1);

	for (int j = 0; j <= i; j++)
	{
		fprintf(fp, "vertex id：%d\n", path[j]);
	}

	if (fp != NULL)
		fclose(fp);

	return 0;
}

crazybobo1207
关注
C/C++ Dijkstra(迪杰斯特拉)算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-17 6653
Dijkstra(迪杰斯特拉)算法是一种用于在带有非负权重的有向图中找到最短路径的算法。它通过从起点开始，不断扩展已知最短路径的顶点来逐步确定最短路径。
单源最短路径——迪杰斯特拉（Dijkstra）算法 C++实现
Nick
12-03 1万+
求最短路径之Dijkstra算法 Dijkstra算法是用来求单源最短路径问题，即给定图G和起点s，通过算法得到s到达其他每个顶点的最短距离。 基本思想：对图G(V,E)设置集合S，存放已被访问的顶点，然后每次从集合V-S中选择与起点s的最短距离最小的一个顶点（记为u），访问并加入集合S。之后，令u为中介点，优化起点s与所有从u能够到达的顶点v之间的最短距离。这样的操作执行n次（n为顶点个数）...
基于C语言利用迪杰斯特拉(Dijkstra)实现自定义城市最短路径
WayneLJL的博客
06-13 2482
利用迪杰斯特拉(Dijkstra)算法求得最短路径
【路径规划】全局路径规划算法——Dijkstra算法（含python实现 | c++实现）
weixin_42301220的博客
05-31 1万+
文章目录参考资料1. 基本概念1.1 算法简介1.2 算法思想1.3 算法图解 参考资料 路径规划与轨迹跟踪系列算法学习 最短路径算法-迪杰斯特拉(Dijkstra)算法 1. 基本概念 1.1 算法简介 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个节点遍历其余各节点的最短路径算法，解决的是有权图中最短路径问题。 它的主要特点是以起始点为中心向外层层扩展(广度优先遍历思想)，直到扩展到终点为止。 1.2 算法思想 设G=(V,E
P3623 [APIO2008]免费道路 题解
Plozia 的小窝
04-29 212
最小生成树好题。 下面规定鹅卵石路长度为 1，水泥路长度为 0，则题中要求的是一棵边权为 kkk 的生成树。 这道题一开始的时候我会认为边权为 1 的边可以随便加，毕竟根据样例来看，删这一条换另一条并没有什么问题。 于是就有一种做法是先选好 kkk 条 1 边，然后剩下的 0 边随意加。 然而根据下面这张图，你就会发现上述做法有问题： ...
【道路工程师小卢】CSP题目 C++实现
JM1307hhh的博客
10-29 1096
【道路工程师小卢】小卢是一名道路工程师，负责铺设一条长度为 n 的道路。铺设道路的主要工作是填平下陷的地表。整段道路可以看作是 n 块首尾相连的区域，一开始，第 i 块区域下陷的深度为 di​。小卢每天可以选择一段连续区间 [L,R]，填充这段区间中的每块区域，让其下陷深度减少 1。在选择区间时，需要保证，区间内的每块区域在填充前下陷深度均不为 0 。 小卢希望你能帮他设计一种方案，可以在最短的时间内将整段道路的下陷深度都变为 0。
Python Dijkstra Algorithm 迪杰斯特拉算法 最短路径算法示例代码
08-10
# Python Dijkstra Algorithm 迪杰斯特拉算法 最短路径算法示例代码 本项目是基于Python的Dijkstra算法示例程序。该程序使用Python实现Dijkstra算法，计算给定图中从一个起始节点到其他节点的最短路径。 示例图的...
C++用Dijkstra(迪杰斯特拉)算法求最短路径
08-31
迪杰斯特拉（Dijkstra）算法是图论中的经典算法之一，由荷兰计算机科学家艾兹格·迪杰斯特拉在1959年提出。它主要用于寻找带权重的有向图中从一个指定顶点（源点）到其他所有顶点的最短路径。这个算法以源点为中心，...
matlab.rar_最短路径_最短路径 matlab_最短路径算法_迪杰斯特拉
09-23
文件"MatlabArithmetic"很可能包含了MATLAB代码示例，演示如何应用迪杰斯特拉算法求解最短路径问题。这些代码可能会涉及以下关键部分： 1. 图数据结构的创建：定义邻接矩阵或邻接表。 2. 初始化距离向量和已访问...
免费道路 BZOJ 3624
weixin_30730151的博客
01-01 61
免费道路 【输入样例】 5 7 21 3 04 5 13 2 05 3 14 3 01 2 14 2 1 【输出样例】 3 2 04 3 05 3 11 2 1 题解： 题意即为求一棵刚好拥有k条鹅卵石路的生成树 那么我们先将所有水泥路加入图中 就可以知道必须要加入的鹅卵石路 将这些边加入新树中 接下来再随意地按树的结构加入至k条鹅卵石路 并再更加随意按...
C/C++数据结构——道路建设（最小生成树Prim）
weixin_44546342的博客
07-27 1544
随着如今社会的不断变化，交通问题也变得越来越重要，所以市长决定建设一些公路来方便各个城市之间的贸易和交易。如果可以的话，输出Yes，否则输出No（两个城市不一定要直接的公路相连，间接公路到达也可以。接下来的n行给出建立公路的成本信息，每行给出三个整数，分别是相连的两个城市v1、v2(0......
铺设道路(c++题解)
hb_zhyu的博客
08-19 952
2.如果a[i]>a[i-1]则还需要多做a[i]-a[i-1]，如上图a,a[4]>a[3],1234填完后的样子如图b，4号坑还有3格未填则要多做3天。一种可行的最佳方案是，依次选择： [1,6]、[1,6]、[1,2]、[1,1]、[4,6]、[4,4]、[4,4]、[6,6]、[6,6]。往后判断：1.如果a[i]<a[i-1]则不需要管他他可以和前面的工程一起做如上图2，3可以和1一起做。这一道题是贪心类型的题目：最重要的是能把a[i]-a[i-1]推出来；NOIP2018 提高组 D1T1。
[luogu]P3623 [APIO2008]免费道路
Myka1991的博客
11-27 160
原题链接：P3623 [APIO2008]免费道路 题意 给定一个图（不一定连通），上面有$m$条$0$边和$1$边。 要求选边使图连通，$0$边的数量必须等于$k$。 分析 一开始用很天真的想法加边：先加鹅卵石路，一直加到$k$条。然后再加水泥路，加到满。 然后发现在洛谷上WA了一个点。 仔细分析一下问题：一对点，如果我们加的是鹅卵石路，那么我们本可以用水泥路使这一...
Dijkstra最短路径算法的C++实现
TechChamp的博客
09-09 103
Dijkstra算法通过逐步确定从源节点到所有其他节点的最短路径，直到找到目标节点或者所有节点都已被遍历。它维护一个距离数组，用于存储源节点到各个节点的当前最短距离。算法的基本思想是不断选择距离最小的节点，更新与该节点相连的节点的最短距离，直到所有节点都被遍历。这就是用C++实现Dijkstra最短路径算法的完整代码。通过这个算法，我们可以找到带权重图中从源节点到其他节点的最短路径。Dijkstra最短路径算法是一种解决带权重图的单源最短路径问题的经典算法。Dijkstra最短路径算法的C++实现。
程序化路网生成器【C++】
最新发布
新缸中之脑
04-28 696
基于OpenGL采用C++开发，可以程序化生成适配给定地形的道路网络。我遇到的问题主要是路网结构不应该是规则的，不像曼哈顿（网格）风格。由于地形不平坦，因此地形的标高应该变化，以便将道路放置在地形表面上。此外，道路与其他道路交叉且没有明显缺陷，并且道路应适应地形的海拔。我的解决方案是使用Voronoi单元使道路网络的形状多样化，每条道路选择其最低海拔不同的路线来绕山。局限性在于，由于系统使用Voronoi，因此很难控制路网的形状。即，用户无法控制道路的特定部分。
c++迪杰斯特拉
iyinhexidemao的博客
06-09 1044
迪杰斯特拉的基本思想是用一个指针，依次从第一号点开始遍历，并且每次遍历过程均用该点来更新其余所有被该点相连的点，到起始处的距离。//指针未开始移动或者，此时点距起点距离更小，并且指针没移到过该点。if(dist[j] > dist[ver] + w[i]){//更新。//输入a，b两个点,c为a，b距离。//邻接矩阵可以看成二维数组，g[a][b]表示点a到点b的距离。g[a][b] = min(g[a][b],c)//初始化。
使用CUDA的GPU上的Bellman-Ford单源最短路径算法
weixin_26726011的博客
09-06 1583
总览 (Overview) Traversing large graphs to compute different information has various use cases in the real-world like social media networks, communication networks, search engine indexing & page ra...
C++版本迪杰斯特拉（Dijkstra）算法原理讲解及代码实现
ZYF的博客
07-01 3070
C++版本迪杰斯特拉（Dijkstra）算法原理及代码实现 在这里插入代码片 在这里插入代码片
Dijkstra算法（c++版）
热门推荐
一串代码的博客
10-21 3万+
迪杰斯特拉算法 最短路径（DP的应用） 单源最短路径，不允许出现负环 核心思想：更新估算距离 时间复杂度与采用的数据结构有关 Array O(v2v^2v2) Binary heap O((V+E)lgV(V+E)lgV(V+E)lgV) Fibonacci heap O(E+VlgVE+VlgVE+VlgV) δ(u,v)≤δ(u,x)+δ(x,v)\delta(u, v) \leq \delt...
迪杰斯特拉最短路径算法【图】
12-03
迪杰斯特拉最短路径算法是一种解决有权图中单源最短路径问题的算法。它采用贪心策略，以起始点为中心向外层层扩展，直到扩展到终点为止。该算法主要特点是将图中的节点集分为最短路径计算完成的节点集S和未计算完成的节点集T，每次将从T中挑选V0->Vt最小的节点Vt加入S，并更新V0经由Vt到T中剩余节点的更短距离，直到T中的节点全部加入S中。迪杰斯特拉算法只支持非负权图，它计算的是单源最短路径，即单个源点到剩余节点的最短路径，时间复杂度为O(n²)。 以下是迪杰斯特拉最短路径算法的具体步骤： 1. 初始化：将起始点s加入S集合，将与s直接相连的节点的距离加入dis数组，将其余节点的距离设为无穷大。 2. 重复执行以下步骤，直到T集合为空： a. 从dis数组中选择值最小的节点v，将其加入S集合。 b. 更新dis数组：对于T集合中的每个节点w，如果存在一条从v到w的边，则计算出v到w的距离，并将其与原有距离进行比较，如果更小则更新dis数组中w的值。 3. 得到起始点s到各个节点的最短路径。 以下是Python实现迪杰斯特拉最短路径算法的代码示例： ```python import sys def dijkstra(graph, start): # 初始化 dis = {node: sys.maxsize for node in graph} # 距离数组 dis[start] = 0 S = set() # 最短路径节点集合 T = set(graph.keys()) # 未计算最短路径节点集合 while T: # 选择距离起点最近的节点 v = min(T, key=lambda node: dis[node]) S.add(v) T.remove(v) # 更新距离数组 for w in graph[v]: if dis[w] > dis[v] + graph[v][w]: dis[w] = dis[v] + graph[v][w] return dis # 测试 graph = { 'A': {'B': 5, 'C': 1}, 'B': {'A': 5, 'C': 2, 'D': 1}, 'C': {'A': 1, 'B': 2, 'D': 4, 'E': 8}, 'D': {'B': 1, 'C': 4, 'E': 3, 'F': 6}, 'E': {'C': 8, 'D': 3}, 'F': {'D': 6} } start = 'A' print(dijkstra(graph, start)) # 输出：{'A': 0, 'B': 3, 'C': 1, 'D': 4, 'E': 7, 'F': 10} ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值