- 算法思想:
Dijkstra算法和Prim算法思想相似,通过定义两个集合,走过的结点位于集合S,未走过的结点位于集合U中,在集合S中寻找是否有更短的路径能够到达未走过的结点,比如A–>B权值为2,B–>C权值5,A–C权值为10,以A为起始点,把A加入集合S中,以A为起点的最短边为A–>B,于是我们把B加入集合S中,未走过的结合U中还剩下C,当要去判断是否有更短的权值能够到达C,由于一开始A是起点,我们已经记录了A–>C的路径,要判断是否能更短的路径,只需在B点的基础上,判断能否有更短的路径到C,即判断A–>B + B–>C 是否小于A–>C,如果存在更短的路径,那么则更新能够到达的最小权值和更新能够到达C更短路径的上一个顶点。 - 用计算机语言去描述两个互斥的集合关系,我们只需将集合中所有结点初始为0,定义为均未走过,如果结点已经走过,那么重新赋值为1即可。dist数组存储当前已找到的从V0到每个终点Vi的最短路径的长度,path保存从V0到Vi最短路径上的前一个顶点。
- 下面我们用下图作为测试用例寻找从0开始到其他顶点的最短路径。
测试结果如下:
源代码如下:
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MaxSize 20
#define INF 99999
typedef struct{
int edges[MaxSize][MaxSize];
int VNode[MaxSize];
int n;
int e;
}MGraph;
void InitMGraph(MGraph* G){
G->e = 12;
G->n = 7;
for (int i = 0; i < G->n; i++) {
for (int j = 0; j < G->n; j++) {
G->edges[i][j] = INF;
}
}
G->edges[0][1] = 4;
G->edges[0][3] = 6;
G->edges[0][2] = 6;
G->edges[1][2] = 1;
G->edges[1][4] = 7;
G->edges[2][5] = 4;
G->edges[2][4] = 6;
G->edges[3][2] = 2;
G->edges[3][5] = 5;
G->edges[4][6] = 6;
G->edges[5][4] = 1;
G->edges[5][6] = 8;
}
void Dijkstra(MGraph* G,int cur){
int S[MaxSize];
int dist[MaxSize];
int path[MaxSize];
for (int i = 0; i < G->n; i++) {
S[i] = 0;
dist[i] = G->edges[cur][i];
if (dist[i]!=INF) {
path[i] = cur;
}else{
path[i] = -1;
}
}
int minIndex;
S[cur] = 1;
for (int j = 0; j < G->n; j++) {
int min = INF;
for (int k = 0; k < G->n; k++) {
if (S[k] != 1 && dist[k] < min) {
min = dist[k];
minIndex = k;
}
}
S[minIndex] = 1;
for (int i = 0; i < G->n; i++) {
if (S[i] != 1 && dist[i] > G->edges[minIndex][i] + dist[minIndex]) {
dist[i] = G->edges[minIndex][i] + dist[minIndex];
path[i] = minIndex;
}
}
}
}
int main(int argc, const char * argv[]) {
MGraph* G = new MGraph();
InitMGraph(G);
Dijkstra(G, 0);
return 0;
}