单源最短路径
dijkstra
- 初介绍
迪杰斯特拉算法采用的是一种贪心的策略。用于求解从源点到其余各点的最短距离。
注意:用dijkstra求解时边权必须为正
- 步骤如下
-
用一个 dist 数组保存源点到其余各个节点的距离,dist[i] 表示源点到节点 i 的距离。初始时,dist 数组的各个元素为无穷大。
-
用一个状态数组 st 记录是否找到了源点到该节点的最短距离,st[i] 如果为真,则表示找到了源点到节点 i 的最短距离,st[i] 如果为假,则表示源点到节点 i 的最短距离还没有找到。初始时,st各个元素为假。
-
初始化:源点到源点的距离为 0。即dist[1] = 0。
-
遍历 dist 数组,找到一个节点,这个节点是:没有确定最短路径的节点中距离源点最近的点。假设该节点编号为 i,此时就找到了源点到该节点的最短距离,st[i] 置为 1。
-
遍历 i 所有可以到达的节点 j,如果 dist[j] 大于 dist[i] 加上 i -> j 的距离,即 dist[j] > dist[i] + w[i][j](w[i][j] 为 i -> j 的距离) ,则更新 dist[j] = dist[i] + w[i][j]。
-
重复 4、5 步骤,直到所有节点的状态都被置为 1。此时 dist 数组中,就保存了源点到其余各个节点的最短距离。
- 伪代码
int dist[n],st[n]; //dist记录的是从源点到点i的最短距离,st记录这个点的最短距离有没有被找到
dist[1] = 0;//第一个点(或源点)到自己的距离为0
state[1] = 1;//标记这个点的最短距离已经被找到了
for(i:1 ~ n) //每个点的最短距离都要找,所以遍历所有的点
{
t <- 找到没有确定最短路径的节点中距离源点最近的点进行更新
st[t] = 1; //更新后打个标记
更新 dist; //对当前点的dist值进行更新
}
- 代码实现——朴素版
代码:
#include<iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510, M = 100010;
int h[N], e[M], ne[M], w[M], idx;//邻接表存储图
int state[N];//state 记录是否找到了源点到该节点的最短距离
int dist[N];//dist 数组保存源点到其余各个节点的距离
int n, m;//图的节点个数和边数
void add(int a, int b, int c)//插入边
{
//边的终点是b
e[idx] = b;
//边的权值是c
w[idx] = c;
//下一个指向h[a]
ne[idx] = h[a];
//把当前节点放在以a开头的链表的最前面
h[a] = idx++;
}
void Dijkstra()
{
//dist 数组的各个元素为无穷大
memset(dist, 0x3f, sizeof(dist));
//从源点到自己的距离为0
dist[1] = 0;//源点到源点的距离为置为 0
//处理其他节点
for (int i = 0; i < n; i++)
{
//找到没有确定最短路径的节点中距离源点最近的点t
int t = -1;
for (int j = 1; j <= n; j++)//遍历 dist 数组
{
//如果这个点的最短路还没找到并且是所有未被更新的距离中最小的
if (!st[j] && (t == -1 || dist[j] < dist[t]))
t = j;
}
st[t] = 1;//标记这个点要更新了
//遍历 i 所有可以到达的节点 j,如果 dist[j] 大于 dist[i] 加上 i -> j 的距离,即 dist[j] > dist[i] + w[i][j](w[i][j] 为 i -> j 的距离) ,则更新 dist[j] = dist[i] + w[i][j]。
for (int j = h[t]; j != -1; j = ne[j])//遍历 t 所有可以到达的节点 i
{
int i = e[j];
dist[i] = min(dist[i], dist[t] + w[j]);//更新 dist[j]
}
}
}
int main()
{
memset(h, -1, sizeof(h));//邻接表初始化
cin >> n >> m;
while (m--)//读入 m 条边
{
int a, b, w;
cin >> a >> b >> w;
add(a, b, w);
}
Dijkstra();
if (dist[n] != 0x3f3f3f3f)//如果dist[n]被更新了,则存在路径
cout << dist[n];
else
cout << "-1";
}
作者:Hasity
-
代码实现——堆优化版
-
为何有堆优化的说法?
看一下算法的时间复杂度:
for(i:1 ~ n) //n次
{
t <- 没有确定最短路径的节点中距离源点最近的点; //每次遍一遍历dist数组,n次的复杂度是O(n^2)
state[t] = 1;
更新 dist; //每次遍历一个节点的出边,n次遍历了所有节点的边,复杂度为O(e)
}
算法的主要耗时的步骤是从dist 数组中选出:没有确定最短路径的节点中距离源点最近的点 t。只是找个最小值而已,没有必要每次遍历一遍dist数组。
在一组数中每次能很快的找到最小值,很容易想到使用小根堆。可以使用库中的小根堆(推荐)或者自己编写。
因此,堆优化主要用于每次在未被更新的点中求出最小值
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>//堆的头文件
using namespace std;
typedef pair<int, int> PII;//堆里存储距离和节点编号,第一维为距离,第二维是记录哪个点
const int N = 1e6 + 10;
int n, m;//节点数量和边数
int h[N], w[N], e[N], ne[N], idx;//邻接表存储图
int dist[N];//存储距离
bool st[N];//存储状态
//建边
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int dijkstra()
{
//初始化:所有边的dist值初始化为无穷打,源点的距离做更新
memset(dist, 0x3f, sizeof dist);//距离初始化为无穷大
dist[1] = 0;
//建立一个小根堆,用于求出最小值
priority_queue<PII, vector<PII>, greater<PII>> heap;//小根堆
//把求出dist最小值的点放进堆中
heap.push({0, 1});//插入距离和节点编号
while (heap.size())
{
//auto自动定义数据类型
//取出堆顶赋值给t,再将它弹出
auto t = heap.top();//取距离源点最近的点
heap.pop();
//记录一下当前这个点(这个哪个点,赋值给ver,这个点的dist是多少,赋值给distance)
int ver = t.second, distance = t.first;//ver:节点编号,distance:源点距离ver 的距离
//看这个点是否已经被算出来,如果被算出来了,就不管它
if (st[ver]) continue;//如果距离已经确定,则跳过该点
//没被算出来,就先标记一下
st[ver] = true;
//用这个点来更新与它直接相连的点的距离
for (int i = h[ver]; i != -1; i = ne[i])//更新ver所指向的节点距离
{
int j = e[i];
if (dist[j] > dist[ver] + w[i])
{
dist[j] = dist[ver] + w[i];
heap.push({dist[j], j});//距离变小,则入堆
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
//建边之前要初始化表头!!!
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
cout << dijkstra() << endl;
return 0;
}
使用小根堆后,找到 t 的耗时从 O(n^2) 降为了 O(1)。每次更新 dist 后,需要向堆中插入更新的信息。所以更新dist的时间复杂度有 O(e) 变为了 O(elogn)。总时间复杂度有 O(n^2) 变为了 O(n + elongn)。适用于稀疏图。
总结
迪杰斯特拉算法适用于求正权有向图中,源点到其余各个节点的最短路径。注意:图中可以有环,但不能有负权边。
bellman-ford
Bellman - ford 算法是求含负权图的单源最短路径的一种算法,效率较低,代码难度较小。其原理为连续进行松弛。
在每次松弛时把每条边都更新一下,若在 n-1 次松弛后还能更新,则说明图中有负环,因此无法得出结果,否则就完成。
因此也可以用来做负环的判断,负环就一个环上,边权之和为负值。
- 初介绍
给定一张有向图,若对于图中的某一条边 (x, y,z),有dist[y]≤ dist[x]+z 成立,则称该边满足三角形不等式。若所有边都满足三角形不等式,则dist数组就是所求最短路。
我们先介绍基于迭代思想的Bellman-Ford算法。它的流程如下:
1.扫描所有边(x, y,z),若dist[y] > dist[x]+z,则用dist[x]+z更新dist[y]。
2.重复上述步骤,直到没有更新操作发生。
Bellman-Ford算法的时间复杂度为O(nm)。
- 明确一下松弛的概念。
考虑节点u以及它的邻居v,从起点跑到v有好多跑法,有的跑法经过u,有的不经过。
经过u的跑法的距离就是distu+u到v的距离。
所谓松弛操作,就是看一看distv和distu+u到v的距离哪个大一点。
如果前者大一点,就说明当前的不是最短路,就要赋值为后者,这就叫做松弛。
- 为何可以来判断负环呢?
更新n-1次,意味着至少经过了n个点;如果还能够更新,则意味着经过的点数要多于n个,即有至少有1个点要被经过两次,为和这个点要经过两次呢?原因只有dist值会在经过后变小,多经过边而总值变小,又重复经过点,可说明有负环存在。
(通俗的来讲就是:假设 1 号点到 n 号点是可达的,每一个点同时向指向的方向出发,更新相邻的点的最短距离,通过循环 n-1 次操作,若图中不存在负环,则 1 号点一定会到达 n 号点,若图中存在负环,则在 n-1 次松弛后一定还会更新)
#include<iostream>
#include<cstring>
using namespace std;
const int N=510,M=10010;
struct Edge{
int a;
int b;
int w;
}e[M];//把每个边保存下来即可
int dist[N];
int back[N];//备份数组放置串联
int n,m,k;//k代表最短路径最多包涵k条边
int bellman_ford(){
memset(dist,0x3f,sizeof dist);
dist[1]=0;
for(int i=0;i<k;i++){//k次循环
memcpy(back,dist,sizeof dist);
for(int j=0;j<m;j++){//遍历所有边
int a=e[j].a,b=e[j].b,w=e[j].w;
dist[b]=min(dist[b],back[a]+w);//使用backup:避免给a更新后立马更新b,这样b一次性最短路径就多了两条边出来
}
}
if(dist[n]>0x3f3f3f3f/2) return -1;
else return dist[n];
}
int main(){
scanf("%d%d%d",&n,&m,&k);
for(int i=0;i<m;i++){
int a,b,w;
scanf("%d%d%d",&a,&b,&w);
e[i]={a,b,w};
}
int res=bellman_ford();
if(res==-1) puts("impossible");
else cout<<res;
return 0;
}
标题spfa
实际上,SPFA算法在国际上通称为“队列优化的 Bellman-Ford算法”,仅在中国大陆流行“SPFA 算法”的称谓。请读者回顾0x26节对“广搜变形”的讨论与总结。
spfa算法文字说明:
-
建立一个队列,初始时队列里只有起始点。
-
再建立一个数组记录起始点到所有点的最短路径(该表格的初始值要赋为极大值,该点到他本身的路径赋为0)。
-
再建立一个数组,标记点是否在队列中。
-
队头不断出队,计算始点起点经过队头到其他点的距离是否变短,如果变短且被点不在队列中,则把该点加入到队尾。取出队头节点x,扫描它的所有出边 (x, y,z),若 dist[y] > dist[x]+z,则使用dist[x]+z更新dist[y]。同时,若y不在队列中,则把y 入队。
-
重复执行直到队列为空。
6 -
在保存最短路径的数组中,就得到了最短路径。
在任意时刻,该算法的队列都保存了待扩展的节点。每次入队相当于完成一次 dist数组的更新操作,使其满足三角形不等式。一个节点可能会入队、出队多次。最终,图中节点收敛到全部满足三角形不等式的状态。这个队列避免了Bellman-Ford 算法中对不需要扩展的节点的冗余扫描,**在随机图上运行效率为0(km)级别,其中k 是一个较小的常数。**但在特殊构造的图上,该算法很可能退化为 0(nm),必须谨慎使用。
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N]; //储存当前点到起点的距离
bool st[N]; //当前点是否在队列当中,防止存重复的点
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0; //起点距自己的距离为 0
queue<int> q;
//队列中放的是点的标号
q.push(1); //起点加入队列
st[1] = true; //起点在队列里了
while (q.size()) //如果队列不空
{
int t = q.front(); //取出队头
q.pop(); //删掉队头
st[t] = false;//这个点已经不在队列里边了
for (int i = h[t]; i != -1; i = ne[i]) //更新 t 的所有邻边
{
int j = e[i]; //取出当前邻边的节点
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j]) //如果 j 不在队列里边
{
q.push(j); //加入队列
st[j] = true; //在队列里了
}
}
}
}
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = spfa();
if (t == 0x3f3f3f3f/2) puts("impossible");
else printf("%d\n", t);
return 0;
}
作者:半瓶可乐
- spfa的优化
SLF优化(Small Label First)
LLL优化(Large Label Last)
参照这里!
https://zhuanlan.zhihu.com/p/536519369