一. 算法思想
Dijkstra算法是按路径长度递增次序产生最短路径的算法。
- 把图的顶点集V分为两组
- S:已求出最短路径的顶点的集合
- T=V-S:尚未确定最短路径的顶点集合
- 把T中顶点按照最短路径递增的次序加入到S中,保证:
- 从源点V0到S中各顶点的最短路径长度都不长于从V0到T中任何顶点的最短路径长度
- 设置辅助数组 d i s t [ n ] dist[n] dist[n],每个分量 d i s t [ k ] dist[k] dist[k]表示当前所求得的从原点到其余各个顶点k的最短路径长度
二.算法步骤
- 设 G [ n ] [ n ] G[n][n] G[n][n]为有向网的带权邻接矩阵,S为已经找到的从源点V0出发的最短路径的终点集合,它的初始状态为{V0},辅助数组 d i s t dist dist的初始值为 d i s t [ i ] = dist[i]= dist[i]=A[V0,Vi],i=1,2,…,n
- 选择Vj(Vj ∈ \in ∈T),使得V0到Vj的距离最短,并令S=S ⋃ \bigcup ⋃{Vj}
- 修改从V0出发到T上任一顶点的最短路径长度,若 d i s t [ j ] + G [ j , i ] < d i s t [ i ] dist[j]+G[j,i]<dist[i] dist[j]+G[j,i]<dist[i],则 d i s t [ i ] = d i s t [ j ] + G [ j , i ] dist[i]=dist[j]+G[j,i] dist[i]=dist[j]+G[j,i]
- 重复步骤2,3,直到所有的顶点都并入S集
三.实现代码
//邻接矩阵
#include <iostream>
using namespace std;
const int MAXV = 1000;
const int INF = 10000;
int n;
int G[MAXV][MAXV];
int dist[MAXV];
bool visited[MAXV];
void Dijkstra(int s)
{
for (int i = 0; i < n; i++) {
dist[i] = INF;
visited[i] = false;
}
dist[s] = 0;
for (int i = 0; i < n; i++) {
int u = -1, MIN = INF;
for (int j = 0; j < n; j++) { //找到尚未作为中间点且距离源点最近的点
if (visited[j] == false && dist[j] < MIN) {
u = j;
MIN = dist[j];
}
}
visited[u] = true;
for (int j = 0; j < n; j++) { //更新距离
if (visited[j] == false && G[u][j] != INF && dist[u] + G[u][j] < dist[j]) {
dist[j] = dis[u] + G[u][j];
}
}
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> G[i][j];
}
}
Dijkstra(0);
for (int i = 0; i < n; i++) {
cout << dis[i] << " ";
}
return 0;
}
//邻接表
struct Node {
int des; //终点
int weight; //权值
};
vector<Node> Adj[MAXV]; //相当于一个二维数组
int n; //顶点数
int dist[MAXV];
bool visited[MAXV];
void Dijkstra(int s) {
for (int i = 0; i < n; i++) {
dist[i] = INF;
visited[i] = false;
}
dist[s] = 0;
for (int i = 0; i < n; i++) {
int u = -1;
int min = INF;
for (int k = 0; k < n; k++) {
if (visited[k] == false && dist[k] < min) {
min = dist[k];
u = k;
}
}
visited[u] = true;
for (int k = 0; k < Adj[u].size(); k++) {
int v = Adj[u][k].des;
if (visited[v] == false && Adj[u][k].weight != INF && dist[u] + Adj[u][k].weight < dist[v]) {
dist[v] = dist[u] + Adj[u][k].weight;
}
}
}
}