最短路径一般算法总结（板子）

1 Bellman-Ford/SPFA

1.1 Bellman-Ford

1.1.1 算法复杂度

  $O(n\ast m)$，其中 n为点数，m为边数。

1.1.2 算法特点

（1）求单源最短路径
（2）可以求负权图
（3）速度慢

1.1.3 算法思路

  这个算法的核心是对边的遍历，每一次遍历都根据边的俩个端点(点i->点j)去更新到j的距离$dis[j]$：
$$dis[j]=min(dis[j],dis[i]+w[i,j])$$
  这样的遍历我们要做$n-1$次，因为每一次遍历全部边都至少得到一个确定好最终最短距离的点，除去起点还有n-1个点，那我们做$n-1$次就能保证完成任务了。

1.2 SPFA

1.2.1 算法复杂度和特点

  最优复杂度可以为$O(n)$，但在稠密图比如完全图中和Bellman-Ford一样都很慢。
  其他方面和B-F算法无异，一般用来求带负权图的单源最短路径。

1.2.2 算法思路

（Shortest Path Faster Algorithm）

  在原来的B-F算法中逐个边遍历n-1次，其中很可能很多次遍历都是不可能获得更新的，就浪费了处理时间。比如一条单链表，后面的边在初始状态下不可能对连接的点的距离更新有贡献。
  所以我们加入了个队列去维护更新后的点，将松弛过的新点入队列，之后再从队列里取点去做遍历，这样我们遍历的边的起点就都是已经松弛过后的点了，也就不会出现上一段提到过的浪费时间情况。

1.2.3 参考代码

例题POJ-2387（注意实题输出和代码中有区别）

// 单源：Bellman-Ford/SPFA
// O(n*m)可以处理负权边，还能检测负环 
// solution:用队列维护拓展点 
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
const int MAXN = 1e3;
typedef struct edge{
	int v,w;  // 连接点编号，边权重 
	edge(int v0,int w0):v(v0),w(w0){}
	bool operator >(const edge &b)const{
		return w>b.w;
	}
}edge;
int n;  // 点数
int dist[MAXN+10];
int in[MAXN+10];  // in the queue?
vector<edge> G[MAXN+10];  // 用edge的vector保存整个图，G[i]表示以i点为起点的边的数组 
void spfa(int p_s){
	queue<int> Q;  // 拓展队列
	for(int i=1;i<=n;i++){  //  dist,in初始化 
		dist[i] = 0x3f3f3f3f;
		in[i] = 0;
	}  
	
	Q.push(p_s);  // 初始点初始化 
	dist[p_s] = 0;
	in[p_s] = 1;
	
	while(!Q.empty()){
		int ft = Q.front();
		Q.pop();
		in[ft] = 0;
		for(int i = 0;i < G[ft].size(); i++){ //遍历来自ft的每一条边 
			if(dist[G[ft][i].v]>dist[ft]+G[ft][i].w){
				dist[G[ft][i].v] = dist[ft]+G[ft][i].w;
				if(!in[G[ft][i].v]){  // 更新点不在队列中，将其入队 
					Q.push(G[ft][i].v);
					in[G[ft][i].v] = 1;
				}
			}
		}
	} 	
} 

int main()
{
	ios::sync_with_stdio(false);
	int T,N;  // 边数，点数。
	cin>>T>>N;
	n = N;
	for(int i=0;i<T;i++){
		int v1,v2,w;
		cin>>v1>>v2>>w;
		G[v1].push_back(edge(v2,w));
		G[v2].push_back(edge(v1,w));	
	}
	spfa(N);  // 这里求以第N个点为起点的单源最短路径

	
	for(int i=1;i<=n;i++){
		cout<<"N-->"<<i<<": ";
		cout<<dist[i]<<endl;
	}
	
	return 0;
} 

2 Dijkstra

2.1 不带堆优化的Dijkstra

2.1.1 算法复杂度

  $O(n^2)$

2.1.2 算法特点

（1）求单源最短路径
（2）不可以求负权图
（3）速度较快，常用算法。

2.1.3 算法思路

（1）维护一个集合，初始状态为一个起点，这个集合表示里面的点的$dist[i]$ 已经是最短路径了。
（2）遍历所有点，取一个集合外的离集合最近的点并入集合，并且用这个点去更新外点到集合的距离
（3）循环n-1次前两步。（实际编程中可以把起点的dist值置为0，其他的为inf，然后直接从空集合开始循环n次即可，看大家编程习惯了）

2.1.4 参考代码

例题POJ-2387（其他定义和main函数参考前面的代码）

void dijkstra(int p_s){  // p_s 为起点下标 
	for(int i=1;i<=n;i++){  // in初始化 
		dist[i] = 0x3f3f3f3f;
		in[i] = 0; 
	}  
	dist[p_s] = 0;
	for(int iii=0;iii<n;iii++){
		// findmin
		int minn = 0x3f3f3f3f;
		int minpos = 0;
		for(int i=1;i<=n;i++){
			if(!in[i]&&dist[i]<minn){
				minn = dist[i];
				minpos = i;
			}
		}
		if(minpos==0){
			//cout<<"非连通图"<<endl;
			break;
		}
		// 最近点入集合并更新 
		in[minpos] = 1;
		for(int i=0;i<G[minpos].size();i++){
			int v = G[minpos][i].v;
			if(dist[v]>minn+G[minpos][i].w){
				dist[v] = minn+G[minpos][i].w;
			}
		}
	}
}

2.2 带堆优化的Dijkstra

2.2.1 算法复杂度和特点

  由于加入了堆优化，每一次找最近点的时间降为了$O(logn)$，总体复杂度为$O(m\ast logn)$。
  一般来说比原始的Dijkstra更快了，但是在边很多比如说完全图的时候复杂度变成了$O(n^2\ast logn)$。选择性使用

2.2.3 算法思路

（1）用一个堆去维护当前集合到各个集合外点的距离信息。方便获得最近点。
（2）从堆中取出最小结点，将其入集合，并决定将邻近外点的距离更新并且入堆。
（3）循环至堆空

2.2.4 参考代码

例题POJ-2387（其他定义和main函数参考前面的代码）

// 堆优化：O(m*logn) 适合稀疏图
void dijkstra(int p_s){
	for(int i=1;i<=n;i++){  //  dist,in初始化 
		dist[i] = 0x3f3f3f3f;
		in[i] = 0;
	}  
	dist[p_s] = 0;
	//in[p_s] = 1;
	priority_queue<edge,vector<edge>,greater<edge> > Q;
	Q.push(edge(p_s,0));
	while(!Q.empty()){
		// 首先获得离集合最近的点信息 
		int ft = Q.top().v;  
		int dis = Q.top().w;
		Q.pop();
		//if(in[ft]) continue;
		// 最近点入集合并更新堆和新的当前最短路径  
		in[ft] = 1;
		for(int i=0;i<G[ft].size();i++){
			int v = G[ft][i].v;
			if(!in[v]&&dist[v]>dis+G[ft][i].w){
				dist[v] = dis+G[ft][i].w;
				Q.push(edge(v,dist[v]));
			}
		}
	}

}

3 Floyd

3.1 算法复杂度

  $O(n^3)$

3.2 算法特点

（1）求多源最短路径
（2）可处理负权图

3.3 算法思路

  其实就是利用动态规划：
$$dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]).$$
  我们要做的是遍历所有中间点k，然后内嵌ij遍历去做到对所有的ij距离的极小化。

3.4 参考代码

int dp[MAXN+10][MAXN+10];
void floyd(){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(dp[i][j]>dp[i][k]+dp[k][j]){
					dp[i][j]=dp[i][k]+dp[k][j];
				}
			}
		}
	}
}