图论（二） 最短路径：Dijkstra算法与Floyd算法

---

图论系列文章

图论（一） 图的DFS与BFS

图论（二） 最短路径：Dijkstra算法与Floyd算法

图论（三）最小生成树：Prim算法与Kruskal算法

图论（四）拓扑排序与关键路径

---

前言

在学习了图的DFS与BFS之后，我们立刻迎来来图的应用：求两顶点之间的最小距离。
其中最为重要的有两种算法：

• Djikstra算法 只能求出一个顶点到其他所有顶点的最短距离
• Floyd算法 能求解出任意两点之间的最小距离

一.BFS求两顶点之间的最短路径（非加权图）

如果是非加权图（或者是权值均为1的加权图），直接使用BFS即可求解出两顶点之间的最短路径。
假设还是以下图作为测试：

• 输入数据

7 10
0 1 
0 2 
1 3 
2 3 
1 4 
3 4 
3 5 
2 5 
4 6 
5 6 

• 程序

int N, C;//N个顶点，C条边
int BFS(vector<vector<int>>& vertex, vector<int>& visited, int start, int end)
{
	queue<int> que;
	que.push(start);
	visited[start] = 1;
	int height = 1;
	while (!que.empty())
	{
		queue<int> tQue;
		while (!que.empty())
		{
			int i = que.front();
			que.pop();
			for (int j = 0; j < N; ++j)
			{
				if (0 == vertex[i][j] || visited[j])//不连通或者已经访问过
					continue;
				if (j == end)
					return height;
				tQue.push(j);
				visited[j] = 1;
			}
		}
		swap(que, tQue);
		height++;
	}
	return 0;
}

int main()
{
	cin >> N >> C;
	vector<vector<int>> vertex(N, vector<int>(N, 0));
	for (int i = 0; i < C; ++i)
	{
		int m, n;
		cin >> m >> n;
		vertex[m][n] = 1;//顶点m到顶点n连通
	}

	//从某一点开始BFS遍历
	vector<int> visited(N, 0);
	cout << "最短路径：" << BFS(vertex, visited, 0, 6) << endl;

	return 0;
}

二.Dijkstra算法求解单源最短路径（加权图）

我们已经了解到，如果是非加权图（或者是权值均为1的加权图）， 直接使用BFS方法就可以算出单源的最短距离。但如果是权值不相等的加权图，那么也就需要使用Dijkstra算法求解。

Dijkstra算法 ：迪克斯特拉算法，是从一个顶点到其余各个顶点的最短路径算法，解决的是有权图中最短路径的问题。

算法思想：

从源顶点开始，采用贪心算法的策略：

1. 每次都选取一个离源顶点距离最近且未访问过的顶点；
2. 计算出该顶点到其他连通顶点的最短距离；
3. 不断重复步骤1与步骤2。

过程中需要设置一个distance数组保存源顶点到其余顶点的最小距离，同时设置一个visited数组判断该顶点是否已经访问过。

• 测试数据

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

• 程序

int N, C;//N个顶点，C条边
void dijkstra(vector<vector<int>>& vertex, vector<int>& visited, int start)
{
	vector<int> distance(N, INT32_MAX);
	distance[start] = 0;
	for (int k = 0; k < N - 1; ++k)//计算源顶点到其他N-1个顶点的最短距离
	{
		int m = 0, Min = INT32_MAX;
		for (int i = 0; i < N; ++i)//每一次都从 没有访问过的 距离最小的 顶点出发
		{
			if (0 == visited[i] && distance[i] < Min)
			{
				Min = distance[i];
				m = i;
			}
		}
	
		visited[m] = 1;
		for (int n = 0; n < N; ++n)
		{
			if (0 < vertex[m][n] && vertex[m][n] < INT32_MAX) //如果m，n之间连通
				distance[n] = std::min(distance[n], vertex[m][n] + distance[m]);
		}
	}

	//print
	for (int i = 0; i < N; ++i)
		cout << distance[i] << endl;
}


int main()
{
	cin >> N >> C;
	vector<vector<int>> vertex(N, vector<int>(N, INT32_MAX));//由于是加权图，不连通则用INT32_MAX表示
	for (int i = 0; i < C; ++i)
	{
		int m, n, weight;
		cin >> m >> n >> weight;
		vertex[m][n] = weight;//顶点m到顶点n连通
		vertex[n][m] = weight;//无向图,顶点n到顶点m连通
	}

	vector<int> visited(N, 0);
	dijkstra(vertex, visited, 0);
	return 0;
}

三.Floyd算法求解多源最短路径

Dijkstra算法只能求解一个点到其他点的最短路径，那么如果要求任意两点之间的最短路径，虽然也可以将Dijkstra算法再执行N次，但是Floyd算法却更简洁有效。

Floyd算法：是一种动态规划算法，用来找到加权图中多个顶点之间的最小距离。

算法思想：

1. 使用邻接矩阵，遍历每个顶点，以该顶点为中继顶点；
2. 在能够作为中继节点到依次计算出最小路径。

dp[i][j] = std::min(dp[i][j], dp[i][k]+dp[k][j]);

• 测试数据

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

• 程序

int N, C;//N个顶点，C条边
void floyd(vector<vector<int>>& vertex)
{
	for (int k = 0; k < N; ++k)
		for (int i = 0; i < N; ++i)
			for (int j = 0; j < N; ++j)
				if (i == j || vertex[i][k] == INT32_MAX || vertex[k][j] == INT32_MAX)//若两点相同，或者中继节点有不连通的情况
					continue;
				else
					vertex[i][j] = std::min(vertex[i][j], vertex[i][k] + vertex[k][j]);

	//print
	for (auto& i : vertex)
	{
		for (auto& j : i)
			cout << j << " ";
		cout << endl;
	}
}	


int main()
{
	cin >> N >> C;
	vector<vector<int>> vertex(N, vector<int>(N, INT32_MAX));//由于是加权图，不连通则用INT32_MAX表示
	for (int i = 0; i < C; ++i)
	{
		int m, n, weight;
		cin >> m >> n >> weight;
		vertex[m][n] = weight;//顶点m到顶点n连通
		vertex[n][m] = weight;//无向图,顶点n到顶点m连通
	}

	floyd(vertex);
	return 0;
}