最短路径（难）

已于 2023-07-23 14:59:04 修改
阅读量707 收藏 1
点赞数 2
分类专栏： 数据结构（王道） 文章标签： 算法 图论
于 2022-12-20 23:32:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/128390635
版权

目录

一、Dijkstra算法

（一）演示

（二）核心代码

（三）完整代码

（四）运行结果

二、Floyd算法

（一）详细介绍 

（二）核心代码

（三）完整代码

（四）运行结果

一、Dijkstra算法

  • Dijkstra算法：可以求带权图中一个顶点到其余各顶点的最短路径（单源最短路径） 
  • 基本算法步骤：
    第一步：初始时，顶点集S只含源点，即S=\left \{ \left. v \right \} \right.,顶点v到自己的距离为0.顶点集U包含除v外其他顶点，源点v到U中顶点i的距离为边上权值。
    第二步：从U中选取一个顶点u，它是源点v到U中距离最小的一个顶点，然后把顶点u加入S中
    第三步：以顶点u作为新考虑的中间点，修改U中那些从顶点u到j有边的顶点j的最短路径长度
    （U中其他顶点从顶点u没有边到达的顶点不需要调整）。考虑顶点u的时候，从源点v到顶点j（j属于U）有如下两条路径，在这两条路径中取更短的路径，求从源点v到顶点j的最短路径长度=min(C_{vj},C_{vu}+W_{uj})    ，其中：
      1.不经过顶点u的路径，路径长度为C_{vj}
      2.从顶点u有一条边到达顶点j的路径，该路径由两段构成，其长度为C_{vu}+W_{uj}
    第四步：重复步骤二和步骤三，直到所有顶点都包含在S中。
  • 算法设计：
    用S数组表示集合S中的元素，即对于顶点j,S[j]=1表示它在S中，S[j]=0表示它在U中
    用dist[j]保存从源点v到顶点j的当前最短路径长度，它的初值为<v,j>边上权值
    用path[j]保存从源点v到j的最短路径，实际上path[j]保存从源点v到顶点j的当前最短路径中顶点j的前一个顶点编号

（一）演示

 

（二）核心代码

void Dijkstra(MGraph G, int v)
{
	int S[MAXV];//用于记录顶点是否在集合U中
	int dist[MAXV];//用于保存从源点到某顶点的当前最短路径长度
	int path[MAXV];//用于保存从源点到某顶点的最短路径
	for (int i = 0; i < G.n; i++)//初始化
	{
		S[i] = 0;
	}
	S[v] = 1;
	for (int i = 0; i < G.n; i++)
	{
		dist[i] = G.edges[v][i];
	}
	for (int j = 0; j < G.n; j++)//path[]数组初始化
	{
		if (S[j]==0&&G.edges[v][j] != INF && G.edges[v][j] != 0)//当v到i没有边的时候
		{
			path[j] = v;
		}
		else
		{
			path[j] = -1;
		}
	}
	
	int u = 0;
	for (int i = 0; i < G.n-1; i++)//循环向S中添加n-1个顶点
	{
		int min = INF;
		for (int k = 0; k < G.n; k++)//选取不在S中并且具有最小距离的顶点
		{
			if (S[k] == 0 && dist[k] < min)
			{
				min = dist[k];
				u = k;
			}
		}
		S[u] = 1;
		for (int i = 0; i < G.n; i++)
		{
			if (S[i] == 0)//仅仅调整不属于S中的顶点的最短路径长度，且需要考虑新加入S中的顶点
			{
				if (G.edges[u][i] + dist[u] < dist[i] && G.edges[u][i] != INF)
				{
					dist[i] = G.edges[u][i] + dist[u];
					path[i] = u;
				}
			}
		}
	}
	Disp(G, S, dist, path, v);
}
void Disp(MGraph G, int S[], int dist[], int path[],int v)
{
	for (int i = 0; i < G.n; i++)
	{
		if (S[i] == 1 && i != v)
		{
			cout << "从" << G.vexs[v] << "到" << G.vexs[i] << "最短路径长度为：" << dist[i]<<endl;
		}
		if (S[i] == 1 && i != v)
		{
			int d[MAXV]={0};
			int m = 0;
			d[m] = i;//先存放路径上的终点
			int k = path[i];
			if (path[i] == -1)
			{
				cout << "无路径！" << endl;
			}
			else
			{
				while (k != v)
				{
					m++;
					d[m] = k;
					k = path[k];
				}
				m++;
				d[m] = v;//添加路径上的起点
				cout << d[m];//先输出起点
				for (int j = m-1 ; j >= 0; j--)
				{
					cout << "->" << d[j];
				}
				cout << endl;
			}
			
		}
	}
}

（三）完整代码

//Dijk.h
#pragma once
#include<iostream>
using namespace std;

#define MAXV 100
#define INF 10000
typedef int EdgeType;
typedef char VertexType;
typedef struct
{
	int n, e;
	EdgeType edges[MAXV][MAXV];
	VertexType vexs[MAXV];
}MGraph;
void Creat(MGraph& G,int A[][MAXV],int n);//创建图的邻接矩阵
void Print(MGraph G);//打印
void Dijkstra(MGraph G, int v);//从v出发到各个顶点的最短路径
void Disp(MGraph G, int S[], int dist[], int path[],int v);//输出路径
void Dijkstra2(MGraph G, int v, int w);//从v出发到u的最短路径
void DispPath(MGraph G, int S[], int dist[], int path[], int v,int u);//输出从v到u的最短路径

//Dijks.cpp
#include"Dijk.h"
void Creat(MGraph& G, int A[][MAXV], int n)
{
	G.n = n;
	G.e = 0;
	cout << "请依次输入顶点信息：";
	for (int i = 0; i < n; i++)
	{
		cin >> G.vexs[i];
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			G.edges[i][j] = A[i][j];
			if (A[i][j] != 0 && A[i][j] != INF)
			{
				G.e++;
			}
		}
	}
}

void Print(MGraph G)
{
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			cout << G.edges[i][j] << " ";
		}
		cout << endl;
	}
}

void Dijkstra(MGraph G, int v)
{
	int S[MAXV];//用于记录顶点是否在集合U中
	int dist[MAXV];//用于保存从源点到某顶点的当前最短路径长度
	int path[MAXV];//用于保存从源点到某顶点的最短路径
	for (int i = 0; i < G.n; i++)//初始化
	{
		S[i] = 0;
	}
	S[v] = 1;
	for (int i = 0; i < G.n; i++)
	{
		dist[i] = G.edges[v][i];
	}
	for (int j = 0; j < G.n; j++)//path[]数组初始化
	{
		if (S[j]==0&&G.edges[v][j] != INF && G.edges[v][j] != 0)//当v到i没有边的时候
		{
			path[j] = v;
		}
		else
		{
			path[j] = -1;
		}
	}
	
	int u = 0;
	for (int i = 0; i < G.n-1; i++)//循环向S中添加n-1个顶点
	{
		int min = INF;
		for (int k = 0; k < G.n; k++)//选取不在S中并且具有最小距离的顶点
		{
			if (S[k] == 0 && dist[k] < min)
			{
				min = dist[k];
				u = k;
			}
		}
		S[u] = 1;
		for (int i = 0; i < G.n; i++)
		{
			if (S[i] == 0)//仅仅调整不属于S中的顶点的最短路径长度，且需要考虑新加入S中的顶点
			{
				if (G.edges[u][i] + dist[u] < dist[i] && G.edges[u][i] != INF)
				{
					dist[i] = G.edges[u][i] + dist[u];
					path[i] = u;
				}
			}
		}
	}
	Disp(G, S, dist, path, v);
}

void Disp(MGraph G, int S[], int dist[], int path[],int v)
{
	for (int i = 0; i < G.n; i++)
	{
		if (S[i] == 1 && i != v)
		{
			cout << "从" << G.vexs[v] << "到" << G.vexs[i] << "最短路径长度为：" << dist[i]<<endl;
		}
		if (S[i] == 1 && i != v)
		{
			int d[MAXV]={0};
			int m = 0;
			d[m] = i;//先存放路径上的终点
			int k = path[i];
			if (path[i] == -1)
			{
				cout << "无路径！" << endl;
			}
			else
			{
				while (k != v)
				{
					m++;
					d[m] = k;
					k = path[k];
				}
				m++;
				d[m] = v;//添加路径上的起点
				cout << d[m];//先输出起点
				for (int j = m-1 ; j >= 0; j--)
				{
					cout << "->" << d[j];
				}
				cout << endl;
			}
			
		}
	}
}
void Dijkstra2(MGraph G, int v, int w)//从v出发到w的最短路径
{
	int S[MAXV];
	int dist[MAXV];
	int path[MAXV];
	for (int i = 0; i < G.n; i++)//初始化S[MAXV]数组
	{
		S[i] = 0;
	}
	S[v] = 1;
	for (int i = 0; i < G.n; i++)//初始化dist[MAXV]数组
	{
		dist[i] = G.edges[v][i];
	}
	for (int i = 0; i < G.n-1; i++)//初始化path[MAXV]数组
	{
		if (G.edges[v][i] != INF && G.edges[v][i] != 0)
		{
			path[i] = v;
		}
		else
		{
			path[i] = -1;
		}
	}

	int k = 0;
	for (int i = 0; i < G.n-1; i++)//循环向S中添加n-1个顶点
	{
		int min = INF;
		for (int j = 0; j < G.n; j++)//选取不在S中并且具有最小距离的顶点
		{
			if (S[j] == 0 && G.edges[v][j] != 0 && dist[j] < min)
			{
				min = dist[j];
				k = j;
			}
		}
		S[k] = 1;
		if (k == w)//如果新加入集合S的顶点恰好是要找的终点，就退出循环
		{
			break;
		}
		else
		{
			for (int j = 0; j < G.n; j++)
			{
				if (S[j] == 0)//更新不属于U中的顶点的最短路径长度
				{
					if (G.edges[v][j] != 0 && G.edges[k][j] + dist[k] < dist[j])
					{
						dist[j] = G.edges[k][j] + dist[k];
						path[j] = k;
					}
				}
			}
		}
		
	}
	DispPath(G, S, dist, path, v, w);
}
void DispPath(MGraph G, int S[], int dist[], int path[], int v, int w)//输出从v到w的最短路径
{
	if (S[w] == 1 && w != v)
	{
		cout << "从" << G.vexs[v] << "到" << G.vexs[w] << "最短路径长度为：" << dist[w] << endl;
	}
	if (S[w] == 1 && w != v)
	{
		int d[MAXV];
		int m = 0;
		d[m] = w;
		int k = path[w];
		while (k != v)
		{
			m++;
			d[m] = k;
			k = path[k];
		}
		m++;
		d[m] = v;
		cout << "最短路径是：" << d[m];
		for (int j = m - 1; j >= 0; j--)
		{
			cout << "->" << d[j];
		}
	}
}

//Text.cpp
#include"Dijk.h"
int main()
{
	int A[][MAXV] = { {0,4,6,6,INF,INF,INF},{INF,0,1,INF,7,INF,INF},{INF,INF,0,INF,6,4,INF},{INF,INF,2,0,INF,5,INF},{INF,INF,INF,INF,0,INF,6},{INF,INF,INF,INF,1,0,8},{INF,INF,INF,INF,INF,INF,0} };
	MGraph G;
	Creat(G, A, 7);
	cout << "图的邻接矩阵：" << endl;
	Print(G);
	Dijkstra(G, 0);
	cout << endl;
	Dijkstra2(G, 2, 6);
	return 0;
}

（四）运行结果

二、Floyd算法

（一）详细介绍 

 

 

 

（二）核心代码

void Floyd(MGraph G)//Floyd算法
{
	int A[MAXV][MAXV];//保存最短路径长度
	int path[MAXV][MAXV];//保存最短路径
	for (int i = 0; i < G.n; i++)//初始化A[][]数组
	{
		for (int j = 0; j < G.n; j++)
		{
			A[i][j] = G.edges[i][j];
		}
	}
	for (int i = 0; i < G.n; i++)//初始化path[][]数组
	{
		for (int j = 0; j < G.n; j++)
		{
			if (G.edges[i][j] == INF || G.edges[i][j] == 0)//i到j不存在边
			{
				path[i][j] = -1;
			}
			else
			{
				path[i][j] = i;//i到j存在边的时候，下标为j的顶点前驱顶点的编号是i
			}
		}
	}
	for (int k = 0; k < G.n; k++)//依次将下标从0到G.n的顶点作为中转点
	{
		for (int i = 0; i < G.n; i++)
		{
			for (int j = 0; j < G.n; j++)
			{
				if ((A[i][k] + A[k][j]) < A[i][j])//找到更短路径长度
				{
					A[i][j] = A[i][k] + A[k][j];//修改路径长度
					path[i][j] = path[k][j];//修改下标为j的顶点的前驱顶点
 //而path[k][j]存放的是恰好是从下标为k到下标为j顶点的路径中，下标为j的顶点的前驱顶点编号
				}
			}
		}
	}
	DisPath(G, A, path);
	/*for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			cout << path[i][j] << " ";
		}
		cout << endl;
	}
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			cout << A[i][j] << " ";
		}
		cout << endl;
	}*/
}
void DisPath(MGraph G, int A[][MAXV], int path[][MAXV])
{
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			if (A[i][j] != 0 && A[i][j] != INF && i != j)
			{
				cout << "从" << G.vexs[i] << "到" << G.vexs[j] << "最短路径长度是：" << A[i][j] << endl;
				int d[MAXV];
				int m = 0;
				d[m] = j;//先存终点的下标
				int k = path[i][j];
				while (k != i && k != -1)
				{
					m++;
					d[m] = k;
					k = path[i][k];
				}
				m++;
				d[m] = i;//存起点的下标
				cout << "路径是：" << d[m];
				for (int p = m - 1; p >= 0; p--)
				{
					cout << "->" << d[p];
				}
				cout << endl;
			}
		}
	}
}

（三）完整代码

//Floyd.h
#pragma once
#include<iostream>
using namespace std;

#define MAXV 100
#define INF 10000
typedef int VertexType;
typedef int EdgeType;
typedef struct
{
	int n, e;
	VertexType vexs[MAXV];
	EdgeType edges[MAXV][MAXV];
}MGraph;
void Creat(MGraph &G, int E[][MAXV], int n);//创建邻接矩阵
void Print(MGraph G);//打印图
void Floyd(MGraph G);//Floyd算法
void DisPath(MGraph G, int A[][MAXV], int path[][MAXV]);//打印最短路径
//Floyd.cpp
#include"Floyd.h"
void Creat(MGraph &G, int E[][MAXV], int n)
{
	G.n = n;
	G.e = 0;
	cout << "请依次输入顶点：";
	for (int i = 0; i < G.n; i++)
	{
		cin >> G.vexs[i];
	}
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			G.edges[i][j] = E[i][j];
			if (E[i][j] != 0 && E[i][j] != INF)
			{
				G.e++;
			}
		}
	}
}
void Print(MGraph G)
{
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			cout << G.edges[i][j] << "　";
		}
		cout << endl;
	}
}

void Floyd(MGraph G)//Floyd算法
{
	int A[MAXV][MAXV];//保存最短路径长度
	int path[MAXV][MAXV];//保存最短路径
	for (int i = 0; i < G.n; i++)//初始化A[][]数组
	{
		for (int j = 0; j < G.n; j++)
		{
			A[i][j] = G.edges[i][j];
		}
	}
	for (int i = 0; i < G.n; i++)//初始化path[][]数组
	{
		for (int j = 0; j < G.n; j++)
		{
			if (G.edges[i][j] == INF || G.edges[i][j] == 0)//i到j不存在边
			{
				path[i][j] = -1;
			}
			else
			{
				path[i][j] = i;//i到j存在边的时候，下标为j的顶点前驱顶点的编号是i
			}
		}
	}
	for (int k = 0; k < G.n; k++)//依次将下标从0到G.n的顶点作为中转点
	{
		for (int i = 0; i < G.n; i++)
		{
			for (int j = 0; j < G.n; j++)
			{
				if ((A[i][k] + A[k][j]) < A[i][j])//找到更短路径长度
				{
					A[i][j] = A[i][k] + A[k][j];//修改路径长度
					path[i][j] = path[k][j];//修改下标为j的顶点的前驱顶点
 //而path[k][j]存放的是恰好是从下标为k到下标为j顶点的路径中，下标为j的顶点的前驱顶点编号
				}
			}
		}
	}
	DisPath(G, A, path);
	/*for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			cout << path[i][j] << " ";
		}
		cout << endl;
	}
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			cout << A[i][j] << " ";
		}
		cout << endl;
	}*/
}


void DisPath(MGraph G, int A[][MAXV], int path[][MAXV])
{
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
		{
			if (A[i][j] != 0 && A[i][j] != INF && i != j)
			{
				cout << "从" << G.vexs[i] << "到" << G.vexs[j] << "最短路径长度是：" << A[i][j] << endl;
				int d[MAXV];
				int m = 0;
				d[m] = j;//先存终点的下标
				int k = path[i][j];
				while (k != i && k != -1)
				{
					m++;
					d[m] = k;
					k = path[i][k];
				}
				m++;
				d[m] = i;//存起点的下标
				cout << "路径是：" << d[m];
				for (int p = m - 1; p >= 0; p--)
				{
					cout << "->" << d[p];
				}
				cout << endl;
			}
		}
	}
}

//Text.cpp
#include"Floyd.h"
int main()
{
	int M[][MAXV] = { {0,5,INF,7},{INF,0,4,2},{3,3,0,2},{INF,INF,1,0} };
	MGraph G;
	Creat(G, M, 4);
	cout << "图的邻接矩阵：" << endl;
	Print(G);
	cout << endl;
	Floyd(G);
	return 0;
}

（四）运行结果

莫忘、莫念
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最短路径（shopth）
Y_X_Y168的博客
05-06 502
最短路径(shopth) 题目描述 给出一个有向图G=(V, E)，和一个源点v0∈V，请写一个程序输出v0和图G中其它顶点的最短路径。只要所有的有向环都是正的，我们就允许图的边有负值。顶点的标号从1到n（n为图G的顶点数）。 注意 可能出现负边权，所以Dijkstra在这里是不可取的 输入 第1行：一个正数n（2<=n<=80），表示图G的顶点总数。 第2行：一个整数，表示源点v0（v0∈V，v0可以是图G中任意一个顶点）。 第3至第n+2行，用一个邻接矩阵W给出了这个图。 输出 共包含n-1
最短路(path)
The wheel of Fortune
09-08 665
时间限制:2000MS内存限制:256000KB 题目描述       给定一个n个点m条边的有向图，有k个标记点，要求从规定的起点按任意顺序经过所有标记点到达规定的终点，问最短的距离是多少。 输入 第一行5个整数n、m、k、s、t，表示点个数、边条数、标记点个数、起点编号、终点编号。 接下来m行每行3个整数x、y、z，表示有一条从x到y的长为z的有向边。 接下来k行每行一个整数表示标记点...
dijkstra算法返回多条最短路径
11-22
java基于dijkstra 算法改进成的返回多条路径
【动态规划】多段图最短路径（动图演示）
Javascript_tsj的博客
05-24 1万+
写在前面： 多段图是一个有向的无环图。求解从起始点v0到终止点的最短路径的长度， 首先看一下这个问题是否具有最优子结构的性质。对于每一点来说，从v0 到它的最短路径有两种可能，分别是从v0直接到该点或者是从最短的前驱 节点开始到该节点。从这里可以看出有递归的性质，所以使用回溯的方法 也是可以解决的。即从终点开始，依次向前找到最短的路径。由于递归本 身所用的时间较长，并且在回溯的过程中存在重复的工作，所以使用动态规划更好。 动图演示： 多段图： 假设图G=(V,E)是一个带权的有向图，如果可以.
多段图最短路径（动态规划法）
最新发布
2301_79582459的博客
05-26 920
问题描述：设图G=(V, E)是一个带权有向图，如果把顶点集合V划分成k个互不相交的子集Vi (2≤k≤n, 1≤i≤k)，使得对于E中的任何一条边(u, v)，必有u∈Vi，v∈Vi+m (1≤i≤k, 1＜i+m≤k)，则称图G为多段图，称s∈V1为源点，t∈Vk为终点。多段图的最短路径问题求从源点到终点的最小代价路径。
多段图动态规划
miss_and_miss的博客
12-23 702
多段图动态规划问题 多段图问题是典型的动态规划问题，动态规划问题最重要的一点是找到他的最优子结构。 由 i 个结点构成的多段图寻找0到 i 结点的最短路径，必然有0到 i -1结点的最短路径 所以我们不妨设置一个数组cost [ n ]来分别表示0到【0-n】各个结点的最短路径 要解决这个问题，每两个结点之间是否连接，连接的长度是多少必不可缺， 所以我们可以再设置一个数组a [ n ] [ n ]来记录任意两个结点之间的长度 当然，不是任意两个结点都会连接，所以之前的初始化我们可以将所有的两点之间的长度
Dijkstra算法在Python上的研究，以及如何修改算法以输出多条最短路径
fwfwxfw的博客
03-19 1200
学图论，第一个遇到的算法就是dijkstra，非常经典。 本文写的是在一个无向图中的dijkstra算法+DFS搜索，可以求一个已知点到其他所有点的最小距离，以及显示遍历所有点的路径。 其中的数据结构和算法，如果还有值得推敲的地方，可以评论探讨。
算法设计与分析——多段图的最短路径问题（Java）
qq_53709454的博客
01-16 3376
不失一般性，将多段图的顶点按照段的顺序进行编号，同一段内顶点的顺序无关紧要。假设图中的顶点个数为 n，则源点 s 的编号为 0，终点t的编号为 n-1，并且对图中的任何一条边，顶点 u 的编号小于顶点 v 的编号。设数组 cost[ n ] 存储最短路径长度，cost[ j ] 表示从源点 s 到顶点 j 的最短路径长度，数组 path[ n ] 记录状态转移，path[ j ] 表示从源点 s 到顶点 j 的路径上顶点 j 的前一个顶点，动态规划法求解多段图的最短路径问题的算法如下。
C/C++ 最短路径-Floyd算法 (路径的保存和输出)
Carizy的博客
07-10 1万+
一、最短路径 最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括： 确定起点的最短路径问题 - 即已知起始结点，求最短路径的问题。 确定终点的最短路径问题 - 与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。 确定起点终点的最短路径问题 - 即已知起点和终点，求两结点之间的最短路径。 全局最短路径问题 - 求图中所有的最
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法是图论中的一个经典问题，用于寻找图中两点之间最短的路径。Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出的一种解决这一问题的有效方法。本篇文章将深入探讨Dijkstra算法的基本原理、...
python实现最短路径的实例方法
01-19
最短路径问题（python实现） 解决最短路径问题：（如下三种算法） （1）迪杰斯特拉算法（Dijkstra算法） （2）弗洛伊德算法（Floyd算法） （3）SPFA算法 第一种算法： Dijkstra算法 广度优先搜索解决赋权有向图或者...
基于gdal 最短路径计算
08-31
在IT行业中，地理信息系统（GIS）的开发与应用经常涉及到空间数据处理，其中包括最短路径的计算。GDAL（Geospatial Data Abstraction Library）是一个强大的开源库，它提供了多种功能，包括读取、写入和操作各种地理...
快递求最短路径
01-11
"快递求最短路径"这个问题涉及到图论中的一个重要算法——最短路径算法。本项目提供的工程实现了这一算法，旨在帮助快递小哥规划出从起点到终点的最优路线。下面将详细阐述相关知识点。 首先，我们要了解图的基本...
lingo解最短路径问题
08-09
lingo解最短路径问题。城市之间线路及距离已知。从某个城市出发，到达目的城市，通过lingo编程选取最短路径。
图算法——求最短路径（Dijkstra算法）
热门推荐
在夜里行走的博客
11-22 8万+
图解Dijkstra算法，让你了解Dijkstra算法的每一步是怎么进行的
输出最短路径
Rushinger
08-02 1711
1.单元最短路径的输出   就是用数组pre记录前驱是哪个，每次更新都是给pre赋值新值 #include&lt;bits/stdc++.h&gt; using namespace std; void prinr(int x) { if(pre[a][x]==0) return;//前驱我们已经设为0 print(pre[a][x]); cout&lt;&lt;"-...
Floyd（多源最短路）证明 + 输出路径
weixin_51979465的博客
08-02 695
因为Dijkstra算法求的是到起点的最短路，但是但是咱们有时候需要求任意两个点之间的最短路，这时候写n遍Dijkstra就会特别麻烦，咱们有位名叫Floyd的大佬就用动态规划的思想创造了Floyd算法，下面看一下这个算法具体的代码 void floyd(){ for (int k = 1; k <= n;k++) for (int i = 1; i <= n;i++) for (int j = 1; j <= n;j++)
[图算法]多段图最短路径
代码帝国
11-15 1万+
[图算法]多段图最短路径多段图最短路径问题是应用动态规划的经典问题之一，许多优化问题都能转化为多段图最短路径问题进而求解。多段图最短路径的问题描述如下：问题描述 设G=(V,E)是一个赋权有向图，其顶点集V被划分为k个不相交的子集Vi(1<=i<=k)，其中，V1和Vk分别只有一个顶点s（称为源）和一个顶点t（称为汇），所有的边(u,v)的始点和终点都在相邻的两个子集Vi和Vi+1中, 且边(u
Floyd算法使用递归输出path路径
weixin_45828673的博客
02-07 621
使用递归的方式输出Floyd算法的path
Dijkstra算法：单源最短路径
"权非负的单源最短路径算法Dijkstra-数据结构最短路径算法" Dijkstra算法是解决图论中一个经典问题——单源最短路径问题的算法，由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出。这个算法适用于寻找带权有向图中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值