C++（算法系列1）：迪杰斯特拉(Dijkstra)算法:最短路径问题

最短路径问题

求出一给定无向图的某顶点零一顶点的最短路径及最短权重
本文代码求出了给定起点到所有其他顶点的最短路径和最短权重。

迪杰斯特拉(Dijkstra)算法

详情请搜索其他讲解

代码详解

定义图节点结构体：（x,y,z）是节点的空间坐标。w包含一组pair<int,int>,每个pair代表该节点的一个邻接节点的编号和权重。

typedef struct node {
	int x;
	int y;
	int z;
	vector<pair<int,int>> w;
}node;

定义图邻接表：每个节点在vector里面的位置+1即为节点编号

vector<node*> g;

定义路径结构体：包含所有点到起点的最短长度，和路径经过的编号数组以及通过的顶点数量

struct path {
	int num;
	int p[100];
	int shortd;
	path():num(0),shortd(INFINITY){}
};

数据定义：

path* p = new path[g.size()];
int* flag = new int[g.size()];
path* f = new path[g.size()];

p是当前所有节点到起点的距离及路径记录；
flag：每个节点已经计算出最短路径，记为1，否则记为0；
f:已经求出的最短路径节点的路径以及最短权重；

首先：

设起点v1
初始化p，flag，f
将v1 设置为 f[v1-1]=1;将v1加入f；
主循环（顶点数-1次）：
找到p中最短权重的节点int short_node = get_shortnode(flag, p);
将节点加入f，即为起点到该节点的最短路径update_f(p, f, short_node);
将该节点的邻接点加入p，更新p，update_p(p, short_node);
将该节点flag设置为1flag[short_node - 1] = 1;

代码示例（邻接表）

输入的顶点坐标和边权重，可以从txt文件直接复制过来输入。
顶点坐标：

边的起点终点以及权重（正数）：

输出：

输入起点编号：

源代码

typedef struct node {
	int x;
	int y;
	int z;
	vector<pair<int,int>> w;
}node;
struct path {
	int num;
	int p[100];
	int shortd;
	path():num(0),shortd(INFINITY){}
};
vector<node*> g;
int get_w(int i,int j) {
	for (auto p : g[i - 1]->w) {
		if (p.first == j)
			return p.second;
	}
	return INFINITY;
}
void print_matrix() {
	cout << "邻接矩阵：" << endl;
	for (int i = 0; i < g.size(); i++) {
		for (int j = 0; j < g.size(); j++) {
			int d = get_w(i+1, j+1);
			cout.flags(ios::left);
			if(d== INFINITY)
				cout << setw(4) << "Inf";
			else
				cout << setw(4) << d;
		}
		cout << endl;
	}
}
void input() {
	cout << "请输入图的顶点数量和边的数量：" << endl;
    int n = 0, m = 0;
	cin>>n>>m;
	//cout<<n<<m<<endl;
	char s[100];
	cout << "请输入顶点坐标（X,Y,Z）：" << endl;;
	for (int i = 0; i < n; i++) {
		node *v = new node;
		cin >> v->x >> v->y >> v->z;
		g.push_back(v);
	}
	cout << "请输入每条边的起点和终点编号（对应前面输入顶点的顺序编号，1开始）和权重"<<endl;
	for (int i = 0; i < m; i++) {
		int v1, v2, d;
		cin >> v1>> v2 >> d;
		if (v1 <= 0 || v2 <= 0 || v1 > n || v2 > n) {
			cout << "数据有误，请重新输入";
			return;
		}
		g[v1 - 1]->w.push_back(pair<int, int>(v2, d));
		g[v2 - 1]->w.push_back(pair<int, int>(v1, d));
	}
}

int get_shortnode(int* flag, path* p) {
	int minlong = INFINITY;
	int n;
	for (int i = 1; i <= g.size(); i++) {
		if (flag[i-1] == 0) {
			if (p[i - 1].shortd < minlong) {
				minlong = p[i - 1].shortd;
				n = i;
			}
		}
	}
	return n;
}
void update_f(path* p, path* f, int short_node) {
	f[short_node - 1].shortd = p[short_node - 1].shortd;
	f[short_node - 1].num = p[short_node - 1].num;
	for (int i = 0; i < p[short_node - 1].num; i++) {
		f[short_node - 1].p[i] = p[short_node - 1].p[i];
	}
}
void update_p(path* p, int short_node) {
	for (auto v : g[short_node - 1]->w) {
		if ((p[short_node - 1].shortd + v.second) < p[v.first - 1].shortd) {
			p[v.first - 1].shortd = p[short_node - 1].shortd + v.second;
			p[v.first - 1].num = p[short_node - 1].num + 1;
			for (int i = 0; i < p[short_node - 1].num; i++) {
				p[v.first - 1].p[i] = p[short_node - 1].p[i];
			}
			p[v.first - 1].p[p[v.first - 1].num - 1] = v.first;
		}
	}
}
void print_path(path* f, int s) {
	for (int i = 1; i <= g.size(); i++) {
		if (i == s)
			continue;
		cout << "(" << g[s - 1]->x << "," << g[s - 1]->y << "," << g[s - 1]->z << ")";
		for (int j = 0; j < f[i - 1].num; j++) {
			cout << " -> " << "(" << g[f[i - 1].p[j] - 1]->x << "," << g[f[i - 1].p[j] - 1]->y << "," << g[f[i - 1].p[j] - 1]->z << ")";
		}
		cout << "  最短路径长度：" << f[i - 1].shortd << endl;
	}
}
void dijkstra(int s) {
	path* p = new path[g.size()];
	int* flag = new int[g.size()];
	path* f = new path[g.size()];
	//初始化
	for (auto v : g[s - 1]->w) {
		p[v.first - 1].shortd = v.second;
		p[v.first - 1].num = 1;
		p[v.first - 1].p[0] = v.first;
	}
	for (int i = 1; i <= g.size(); i++) {
		if (i != s)
			flag[i - 1] = 0;
		else
			flag[i - 1] = 1;
	}
	f[s - 1].num = 0; f[s - 1].shortd = 0;

	for (int i = 1; i < g.size(); i++) {
		int short_node = get_shortnode(flag, p);
		update_f(p, f, short_node);
		update_p(p, short_node);
		flag[short_node - 1] = 1;
	}
	print_path(f, s);
}

int main()
{
	input();
	print_matrix();
	cout << "请输入起点编号（1-" << g.size() << "）：";
	int s;
	cin >> s;
	dijkstra(s);

	return 0;
}