为什么要用dijikstra?
首先分析一下最常见的三种最短路算法的情况
算法名称 时间复杂度(最好) 时间复杂度(最坏) 空间复杂度 用途
Dijkstra O(N^2) O(N^2) O(N) 单源
SPFA O(KM)(k为常数) O(NM) O(N) 单源
Floyd O(N^3) O(N^3) O(N^2) 多源
可以知道,SPFA是比较不稳定的(比如说在NOI的归程中),SPFA算法由于它上限 O(NM)=O(VE)的时间复杂度,被卡掉的几率很大,所以我们需要Dijkstra算法。
Dijkstra的时间复杂度稳定在O(N^2),是一种非常理想的时间复杂度(重点在稳定)。
什么是dijkstra?
dijkstra是一种单源最短路径算法,时间复杂度上限为O(n^2)(朴素),在实际应用中较为稳定;加上堆优化之后更是具有O((n+m)log2n)的时间复杂度,在稠密图中有不俗的表现。
(1)求解思路——从始点出发,逐步顺序地向外探寻,每向外延伸一步都要求是最短的。
(2)使用条件——网络中所有的弧权均非负。
我们把点分成两类,一类已知从始点到该标号点的最短路权的点,看为"白点"(Permanent永久性),另一类是未确定最短路径的点,看为"蓝点"(仅知从始点到该标号点的最短路权 上界 ,Temporary临时性)
dijkstra的流程如下:
- 初始化dis[start]=0,其余节点的dis值为无穷大.
- 找一个dis值最小的蓝点x,把节点x变成白点.
- 遍历x的所有出边(x,y,z),若dis[y]>dis[x]+z,则令dis[y]=dis[x]+z
- 重复2,3两步,直到所有点都成为白点…
dijkstra为什么是正确的
当所有边长都是非负数的时候,全局最小值不可能再被其他节点更新.所以在第2步中找出的蓝点x必然满足:dis[x]已经是起点到x的最短路径…我们不断选择全局最小值进行标记和拓展,最终可以得到起点到每个节点的最短路径的长度
图解:
(令start=1)
开始时我们把dis[start]初始化为0,其余点初始化为inf
第一轮循环找到dis值最小的点1,将1变成白点,对所有与1相连的蓝点的dis值进行修改,使得dis[2]=2,dis[3]=4,dis[4]=7
第二轮循环找到dis值最小的点2,将2变成白点,对所有与2相连的蓝点的dis值进行修改,使得dis[3]=3,dis[5]=4
第三轮循环找到dis值最小的点3,将3变成白点,对所有与2相连的蓝点的dis值进行修改,使得dis[4]=4
接下来两轮循环分别将4,5设为白点,算法结束,求出所有点的最短路
为什么dijkstra不能处理有负权边的情况?
我们来看下面这张图
2到3的边权为−4,显然从1到3的最短路径为−2 (1→2→3).但在循环开始时程序会找到当前dis值最小的点3,并标记它为白点.
这时的dis[3]=1,然而1并不是起点到3的最短路径.因为3已经被标为白点,所以dis[3]不会再被修改了.我们在边权存在负数的情况下得到了错误的答案.
dijkstra的堆优化?
这个算法和prim算法非常相似,也是不断扩展一棵树,只是prim算法每次选一个权值最小的边来扩张,本算法是选一个路径值最小的点来扩张。类似地,Dijkstra算法也可以借助堆来优化效率。
观察可以发现,步骤2可以用堆对dis数组进行维护,用O(log2n)的时间取出堆顶元素并删除,用O(log2n)遍历每条边,总复杂度O((n+m)log2n)。
#include<bits/stdc++.h>
const int MaxN = 100010, MaxM = 500010;
struct edge{
int to, dis, next;
}e[MaxM];
int head[MaxN], dis[MaxN], cnt;
bool vis[MaxN];
int n, m, s;
inline void add_edge( int u, int v, int d )
{
cnt++;
e[cnt].dis = d;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
struct node
{
int dis;
int pos;
bool operator <( const node &x )const
{
return x.dis < dis;
}
};
std::priority_queue<node> q;
inline void dijkstra()
{
dis[s] = 0;
q.push( ( node ){0, s} );
while( !q.empty() )
{
node tmp = q.top();
q.pop();
int x = tmp.pos, d = tmp.dis;
if( vis[x] )
continue;
vis[x] = 1;
for( int i = head[x]; i; i = e[i].next )
{
int y = e[i].to;
if( dis[y] > dis[x] + e[i].dis )
{
dis[y] = dis[x] + e[i].dis;
if( !vis[y] )
{
q.push( ( node ){dis[y], y} );
}
}
}
}
}
int main()
{
scanf( "%d%d%d", &n, &m, &s );
for(int i = 1; i <= n; ++i)dis[i] = 0x7fffffff;
for( register int i = 0; i < m; ++i )
{
register int u, v, d;
scanf( "%d%d%d", &u, &v, &d );
add_edge( u, v, d );
}
dijkstra();
for( int i = 1; i <= n; i++ )
printf( "%d ", dis[i] );
return 0;
}
后记
本文部分内容摘自李煜东《算法竞赛进阶指南》和《信息学竞赛一本通》
友情提示:正权图请使用dijkstra算法,负权图请使用SPFA算法
转自(并编辑)A simple dispiction of dijkstra.