Dijkstra算法求解无向图一点到其他各点的最短路径

Dijkstra求解最短路径

有一无向带权图，求解顶点V1到其他各顶点的最短路径。

实现代码

#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;

struct edge {
	int start;//起点
	int end;//终点
	int distance;//距离 (边权)
	edge(int s, int e, int d) :start(s), end(e), distance(d) {}
};

void init(vector<edge>& edges, vector<vector<int>>& inf);
void Dijkstra(vector<vector<int>>& inf, int fir, int& n);
void findPath(vector<pair<int, int>> path, vector<vector<int>>& inf, int fir, int& n);
//初始化邻接矩阵
void init(vector<edge>& edges, vector<vector<int>>& inf) {
	edges.push_back(edge(0, 1, 20));
	edges.push_back(edge(1, 2, 9));
	edges.push_back(edge(2, 3, 5));
	edges.push_back(edge(3, 4, 4));
	edges.push_back(edge(4, 5, 28));
	edges.push_back(edge(5, 0, 23));
	edges.push_back(edge(6, 0, 1));
	edges.push_back(edge(6, 1, 4));
	edges.push_back(edge(6, 2, 15));
	edges.push_back(edge(6, 3, 16));
	edges.push_back(edge(6, 4, 25));
	edges.push_back(edge(6, 5, 36));
	for (int i = 0; i < edges.size(); i++) {
		inf[edges[i].start][edges[i].end] = edges[i].distance;
		inf[edges[i].end][edges[i].start] = edges[i].distance;
	}
}


void Dijkstra(vector<vector<int>>& inf, int fir, int& n) {//求解 fir 点到其他各点的最短路径
	unordered_set<int> result;//加入到结果集的点
	vector<pair<int, int>> path(n, make_pair(fir, INT_MAX / 2));//路径数组
	int cur = fir;//当前正寻找最短路径的点 fir - > cur 
	path[cur] = make_pair(fir, 0);//到自己的距离为0
	result.insert(cur);
	
	for (int i = 1; i < n; i++) {//剩下的n - 1个点都需要得出最短路径(第一个点不需要寻找)
		//选择当前状态下最短路径的点作为拓展节点
		for (int j = 0; j < n; j++) {
			if (inf[cur][j] != 0 && result.find(j) == result.end()) {
				//cur 与 j 存在路径 且 该点还未找到最优路径 : 不在结果集中 此时视情况更新j的路径距离
				int tmp = inf[cur][j] + path[cur].second;
				if (tmp < path[j].second) {
					path[j].second = tmp;
					path[j].first = cur;
				}
			}
		}

		int minimum = INT_MAX;
		int next = -1;//用于寻找下一次的拓展节点
		for (int k = 0; k < n; k++) {
			if (result.find(k) == result.end()) {
				if (path[k].second < minimum) {
					minimum = path[k].second;
					next = k;
				}
			}
		}
		cur = next;
		result.insert(cur);
	}
	findPath(path, inf, fir, n);
}

void findPath(vector<pair<int, int>> path,vector<vector<int>>& inf, int fir, int& n) {
	for (int i = 0; i < n; i++) {
		if (i == fir) continue;
		vector<int> curPath;
		int cur = i;
		while (1) {
			curPath.push_back(cur);//将之前的点加入到路径数组中
			if (cur == fir)
				break;
			cur = path[cur].first;//继续向前寻找
		}
		cout << "\n从V" << fir + 1 << "到V" << i + 1 << "的最短路径为\n";
		for (int j = curPath.size() - 1; j >= 1; j--) {
			cout << "V" << curPath[j] + 1 << " -> ";
		}cout << "V" << curPath[0] + 1;
		cout << endl << "距离为" << path[i].second << endl;
	}
}

int main() {
	int n = 7;
	vector<vector<int>> inf(n, vector<int>(n, 0));//临界矩阵
	vector<edge> edges;//存储图中各边的信息
	init(edges, inf);
	Dijkstra(inf, 1, n);
	return 0;
}

运行效果

---

代码重构 2022.8.8

重构内容：

• 清晰命名
• 用类封装数据结构

#include <iostream>
#include <vector>
using namespace std;

static int g_pointNum;
static int g_startPoint;
const int INFINITE = INT_MAX / 2;

struct Edge {
	int _start;
	int _end;
	int _weight;
	Edge(int s, int e, int w) :
		_start(s), _end(e), _weight(w) {}
};

class Graph {
public:
   /*
	* @param edges: 传入参数，初始化 _edges
	* 为_matrix分配空间，并初始化为 0
	*/
	Graph(vector<Edge>& edges) : 
		_edges(std::move(edges)) {
		_matrix.reserve(g_pointNum * g_pointNum);
		_matrix.resize(g_pointNum);
		
		for (auto& vec : _matrix) {
			vec.resize(g_pointNum, INFINITE);
		}
	}

	void InitMatrix();
	void Dijkstra();
private:
	vector<vector<int>> _matrix;
	vector<Edge> _edges;
};

void Graph::InitMatrix() {
	for (auto& edge : _edges) {
		int start = edge._start;
		int end = edge._end;
		int weight = edge._weight;
		_matrix[start][end] = weight;
		_matrix[end][start] = weight;
	}
}

void Graph::Dijkstra() {
	vector<int> minWeight(g_pointNum, INFINITE);   // 记录起点到其他点的最小代价
	vector<bool> complete(g_pointNum, false); // 记录已经完成计算的点
	minWeight[g_startPoint] = 0;
	complete[g_startPoint] = true;

	int curPoint = g_startPoint; // 当前的拓展节点

	int minWgt = INFINITE; // 记录初始化时的最小值
	int nextPoint = 0;
	for (int i = 0; i < g_pointNum; ++i) {
		int weight = _matrix[curPoint][i];
		minWeight[i] = weight;
		if (minWgt > weight) {
			minWgt = weight;
			nextPoint = i; // 保存下一个扩展节点
		}
	}
	
	// 进行 g_pointNum - 2 轮即可计算出到所有点的最短距离
	for (int i = g_pointNum - 1; i > 0; --i) {
		curPoint = nextPoint;
		minWgt = INFINITE;
		for (int j = 0; j < g_pointNum; ++j) {
			if (complete[j] || _matrix[curPoint][j] == INFINITE) {
				continue;
			}

			if (minWeight[curPoint] + _matrix[curPoint][j] < minWeight[j]) {
				minWeight[j] = minWeight[curPoint] + _matrix[curPoint][j];
			}
			if (minWgt > minWeight[j]) {
				minWgt = minWeight[j];
				nextPoint = j;
			}
		}
		complete[nextPoint] = true;
	}

	for (int i = 0; i < g_pointNum; ++i) {
		if(i != g_startPoint)
		cout << g_startPoint << " -> " << i <<
			" min-weight: " << minWeight[i] << endl;
	}
}

int main() {
	g_pointNum = 7; // 图拥有的点数量
	g_startPoint = 1; // 起点

	vector<Edge> edges;
	// 图中所有边 V1 ~ V7分别对应索引0 ~ 6
	edges.push_back(Edge(0, 1, 20));
	edges.push_back(Edge(1, 2, 9));
	edges.push_back(Edge(2, 3, 5));
	edges.push_back(Edge(3, 4, 4));
	edges.push_back(Edge(4, 5, 28));
	edges.push_back(Edge(5, 0, 23));
	edges.push_back(Edge(6, 0, 1));
	edges.push_back(Edge(6, 1, 4));
	edges.push_back(Edge(6, 2, 15));
	edges.push_back(Edge(6, 3, 16));
	edges.push_back(Edge(6, 4, 25));
	edges.push_back(Edge(6, 5, 36));

	Graph graph(edges);
	graph.InitMatrix();
	graph.Dijkstra();
	return 0;
}

输出结果