最短路径算法汇总

Dijkstra

d[0]=0;d[1~n]=INF;

1选最小的d[i];

2从i点出发所有边 松弛d[j]

伪代码：

for(1~n)

{

所有未标记的点选出d最小的点x;

标记x点走过;

i点出发所有边 更新d[y]=min(d[y],d[x]+w[x][y]); // <x,y>属于E;

}

1)简易版：O(n*n)

对边编号：u[i],v[i] 表示第i边连通哪两点 v[i]为i点标记;

memset(v,0,sizeof(v));
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
int x,m=INF;
for(int y=0;y<n;y++) if(!v[y]&&m>=INF) m=d[y],x=y;  //选出最小的d[x];
v[x]=1;
for(int y=0;y<n;y++) d[y]=min(d[y],d[x]+w[x][y]);   //更新d[y];
}

打印路径：将 for(int y=0;y<n;y++) d[y]=min(d[y],d[x]+w[x][y]);

换为 for(int y=0;y<n;y++) if(d[y]>d[x]+w[x][y]) d[y]=d[x]+w[x][y],path[y]=x;

2)优化版 O(m*logn)

对点编号 vector<int> G[maxn]; 保存邻接表;

优先队列取出d[i]最小的，就不用O(n)找出d[i]最小的了;

struct Edge
{
int from,to,dist;
Edge(int u,int v,int w) : from(u),to(v),dist(w) {}
};
struct HeapNode
{
int d,u;
bool operator < (const HeapNode& rhs) const {
return d<rhs.d;
}
}
vector<int> G[maxn]; //G[u][i] 表示u点连接的边的编号;
vector<Edge> edges; //保存对应边的编号的一切信息
bool vis[maxn]; //
int d[maxn]，path[maxn];
void dijkstra(int s)
{
priority_queue<HeadNode> Q;
Q.push(HeadNode(0,s));
for(int i=0;i<n;i++) d[i]=INF,vis[i]=false;
d[s]=0;
while(!Q.empty())
{
HeapNode x=Q.top();Q.pop();
int u=x.u;
if(vis[u]) continue;
vis[u]=true;
for(int i=0;i<G[u].size();i++)
{
Edge e=edges[G[u][i]];
if(d[e.to]>d[e.from]+e.dist)
{
d[e.to]=d[e.from]+e.dist;
path[e.to]=G[u][i];
Q.push(HeapNode(e.to,e.dist));
}
}
}
}
打包成下面
struct Dijkskra
{
int n,m;
vector<int> G[maxn]; //G[u][i] 表示u点连接的边的编号;
vector<Edge> edges; //保存对应边的编号的一切信息
bool vis[maxn]; //
int d[maxn]，path[maxn];
void init(int n)
{
this->n=n;
for(int i=0;i<n;i++) G[i].clear();
edges.clear();
}
void AddEdge(int from,int to,int dist)
{
edges.push_back(from,to,dist);
m=edges.size();
G[from].push_back(m-1);
}
void dijkstra(int s)
{
priority_queue<HeadNode> Q;
Q.push(HeadNode(0,s));
for(int i=0;i<n;i++) d[i]=INF,vis[i]=false;
d[s]=0;
while(!Q.empty())
{
HeapNode x=Q.top();Q.pop();
int u=x.u;
if(vis[u]) continue;
vis[u]=true;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges[G[u][i]];
if(d[e.to]>d[e.from]+e.dist)
{
d[e.to]=d[e.from]+e.dist;
path[e.to]=G[u][i];
Q.push(HeapNode(e.to,e.dist));
}
}
}
}
}

Bellman-Ford

对每个已更新过的节点都更新其相连的节点;

最短路最多经过n-1点（起点不算），经过m条边;

伪码描述

for(1~n-1) //最多检查n-1次

for(1~m) //每次每条边都要检查

{

if(x点已经更新) 更新周围的点;

}

因为Dijkstra是每次取出最小d[i]，当存在负权就会出现问题;

而使用Bellman-Ford只是随意取出相邻边所以不会出现问题;

但正是因为是随意取出相邻边，所以对于每个节点要多次检查;

即 每个节点可以多次进入并检查该节点是否能更新 ，直到无法更新周围点;

对于起点i，其他的点都要扫一遍n-1，对于每一点相邻的边都要走一遍m

//简易版  O(m*n)
for(int i=0;i<n;i++) d[i]=INF;
d[0]=0;
for(int k=0;k<n-1;k++)
for(int i=0;i<m;i++)
{
int x=u[i],y=v[i];
if(d[x]<INF) d[y]=min(d[y],d[y]+w[i]);
//if(x点更新过) //因为只有更新过才能更新你周围的点;
}
//优化版
队列优化  O(m*n) 但实际更快
bool inq[maxn];  //即inqueue 表示该点已经压入队列；
int cnt[maxn]; //记录每个点收录次数，当出现cnt[i]>n 则说明不存在最短路径 ;
bool Bellman-ford(int s)
{
queue<int> Q;
memset(inq,0,sizeof(inq));
memset(cnt,0,sizeof(cnt));
for(int i=0;i<n;i++) d[i]=INF;
d[s]=0;
Q.push(s);
while(!Q.empty())
{
int u=Q.front();Q.pop();
inq[u]=false;     //Q中取出来了，标为false;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges(G[u][i]);
if(d[u]<INF&&d[e.to]+e.dist)  //若d[u]是INF表明u点未被更新，也就不用更新其周围的点;
{
d[e.to]=d[u]+e.dist;
path[e.to]=G[u][i];
if(!inq[e.to])
{
Q.push(e.to);
inq[e.to]=true;  //e.to点放入queue ，标识为true;
if(++cnt[e.to]>n) return false;  //图不通;
}
}
}
}
return true;
}

有三点要注意

1）每次for循环e.to只能压入队列一次，所以要用inq标识 ;

2）每个节点最多要放入队列n次（因为每个节点至少放入队列一次，若每个节点都可连通到x点，那么x点要进入队列n次）

所以cnt[e.to]>n 表明无最短路，可能存在负环;

3）每当e.to被更新过，就要放入队列更新e.to相连的点，直到所有的点都更新完，算法结束;

Floyd 多源最短路径 O(n^3)

通过一个图的权值矩阵求出它的每两点间的最短路径矩阵

i~j 要经过k点

d[0~n][0~n]=INF;
d[0][0]=0;
for(int k=0;k<n;k++)
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
if(d[i][j]<INF&&d[k][j]<INF)
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}