Dijkstra算法只能应对素有边权都是非负数的情况,如果边权出现负数,那么Dijkstra算法很可能会出错,这时最好使用SPFA算法。
邻接矩阵版【带权有向图】
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXV = 1000;//最大顶点数
const int INF = 1000000000;//设INF为一个很大的数
//邻接矩阵版,适用于点数不大的情况
//n为顶点数,MAXV为最大顶点数
int n=6,G[MAXV][MAXV]={
{0,1,INF,4,4,INF},
{INF,0,INF,2,INF,INF},
{INF,INF,0,INF,INF,1},
{INF,INF,2,0,3,INF},
{INF,INF,INF,INF,0,3},
{INF,INF,INF,INF,INF,0}
};
int d[MAXV];//起点到达各点的最短路径长度
bool vis[MAXV]={false};//标记数组,vis[i]==true表示已访问。初值均为false
void Dijkstra(int s) {//s为起点
fill(d,d+MAXV,INF);//fill函数将整个d数组赋为INF(慎用memset)
d[s] = 0;//起点s到达自身的距离为0
for(int i=0;i<n;i++) {//循环n次
int u = -1,MIN = INF;//u使d[u]最小,MIN存放该最小的d[u]
for(int j=0;j<n;j++) {//找到未访问的顶点中d[]最小的
if(vis[j]==false&&d[j]<MIN){
u = j;
MIN = d[j];
}
}
//找不到小于INF的d[u],说明剩下的顶点和起点s不连通
if(u==-1) return;
vis[u] = true;//标记u为已访问
for(int v=0;v<n;v++){
//如果v未访问&&u能到达v&&以u为中介点可以使d[v]更优
if(vis[v]==false&&G[u][v]!=INF&&d[u]+G[u][v]<d[v]) {
d[v] = d[u]+G[u][v];//优化d[v]
}
}
}
}
int main(){
//邻接矩阵版的Dijkstra算法时间复杂度为O(v*v)
Dijkstra(0);
for(int i=0;i<n;i++){
cout<<d[i]<<" ";//代表了从起点0到终点i的最短距离[0,1,5,3,4,6]
}
return 0;
}
邻接表版
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXV = 1000;//最大顶点数
const int INF = 1000000000;//设INF为一个很大的数
struct Node{
int v;//v为边的目标顶点
int dis;//dis为边权
Node(int _v,int _dis){
v = _v;
dis = _dis;
}
};
//图G,Adj[u]存放从顶点u出发可以到达的所有顶点
Node* p01 = new Node(1,1);
Node* p03 = new Node(3,4);
Node* p04 = new Node(4,4);
Node* p13 = new Node(3,2);
Node* p25 = new Node(5,1);
Node* p34 = new Node(4,3);
Node* p32 = new Node(2,2);
Node* p45 = new Node(5,3);
vector<Node> Adj[MAXV]={
{*p01,*p03,*p04},
{*p13},
{*p25},
{*p34,*p32},
{*p45},
{}
};
int n=6;//n为顶点数,图G使用邻接表实现,MAXV为最大顶点数
int d[MAXV];//起点到达各点的最短路径长度
bool vis[MAXV]={false};//标记数组,vis[i]==true表示已访问。初值均为false
void Dijkstra(int s) {//s为起点
fill(d,d+MAXV,INF);//fill函数整个d数组赋为INF(慎用memset)
d[s] = 0;//起点S到达自身的距离为0
for(int i=0;i<n;i++) {//循环n次
int u=-1,MIN = INF;//u使d[u]最小,MIN存放该最小的d[u]
for(int j=0;j<n;j++) {//找到未访问的顶点中的d[]最小的
if(vis[j]==false&&d[j]<MIN){
u = j;
MIN = d[j];
}
}
//找不到小于INF的d[u],说明剩下的顶点和起点s不连通
if(u==-1) return;
vis[u] = true;//标记u为已访问
//只有下面这个for循环与邻接矩阵的写法不同
for(int j=0;j<Adj[u].size();j++) {
int v = Adj[u][j].v;//通过邻接表直接获得u能到达的顶点v
if(vis[v]==false&&d[u]+Adj[u][j].dis<d[v]) {
//如果v未访问&&以u为中介点可以使d[v]更优
d[v] = d[u]+Adj[u][j].dis;//优化d[v]
}
}
}
}
int main(){
//邻接表版的复杂度为O(V*V+E)
Dijkstra(0);
for(int i=0;i<n;i++){
cout<<d[i]<<" ";//代表了从起点0到终点i的最短距离[0,1,5,3,4,6]
}
return 0;
}