Dijkstra算法

 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;
}