Dijkstra算法
对于一个边权为正的图,我们可以利用Dijkstra算法求出单源最短路径(SSSP),对于常规的Dijkstra算法,其复杂度为 O ( n 2 ) O(n^2) O(n2) ,显然在 n n n 较大的时候,可能导致耗时过长,通过优化我们可以获得一种更加快速的Dijkstra算法,时间复杂度为 O ( m l o g n ) O(mlogn) O(mlogn) 。
优化思想
在传统的Dijkstra算法中,在 d[n]
中寻找未被访问且最小的 d[i]
采用的是遍历数组的方式,这样会导致时间的复杂度变高,既然是输出最小的权值边,那么我们可以用STL中的 priority_queue
的优先队列来实现这一操作,可以实现加速。当然,为了实现这一操作,我们存储图也不再利用简单的邻接矩阵,而是先存储边的数据,再将边的数据存储到 vector
数组中,有点像邻接表,但不是邻接表。
代码
代码源于《算法竞赛入门经典(第2版)》(紫书)
struct Edge
{
int from, to, dist;
Edge(int u,int v,int d):from(u),to(v),dist(d){}
};
struct HeapNode{
int d, u;
bool operator <(const HeapNode & rhs) const{
return d > rhs.d;
//这里用>与上面operator所定义的相反是为了让优先队列中最小的值先pop
}
};
struct Dijkstra
{
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn];
int d[maxn];
int p[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(Edge(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s){
priority_queue<HeapNode> Q;
for (int i = 0; i < n;i++)
d[i] = INF;
d[s] = 0;
memset(done, 0, sizeof(done));
Q.push((HeapNode){0, s});
while(!Q.empty()){
HeapNode x = Q.top();
Q.pop();
int u = x.u;
if(done[u])
continue;
done[u] = true;
for (int i = 0; i < G[u].size();i++){
Edge &e = edges[G[u][i]];
if(d[e.to] > d[u] + e.dist){
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
Q.push((HeapNode){d[e.to], e.to});
}
}
}
}
};
例题
看了上述的代码,不妨来做道题试试。
题目:J-free:https://ac.nowcoder.com/acm/contest/884/J
题意:给定一个图,有
n
n
n 个点,
m
m
m 个边,每个边的权值为
l
l
l, 你可以让图上至多
k
k
k 个边的权值变为
0
0
0,请问,在这样的操作过后,从顶点
S
S
S 到顶点
T
T
T 的最短路径是多少。
题解:在了解了上述的关于堆优化的Dijkstra算法过后,对于解这题很有帮助。由于到点的距离与
k
k
k 有了关系,我们不能再用原先的一维数组 d[n]
来存储到各个点的距离的最短路径,而是要开一个二维数组 dis[n][m]
,其中 dis[i][j]
表示从源点到顶点
i
i
i 在使
j
j
j 个边的权值变成
0
0
0 的情况下的最短路径。这样我们就很容易地可以获得答案了。那么要如何建立这个二维数组 dis[n][m]
呢,在原先的Dijkrstra算法中,我们向Q中push一个HeapNode的条件是 d[e.to] > d[u] + e.dist
,在这里由于多了一个考虑因素
k
k
k ,所以我们的HeapNode中要增加一个变量ktime
来表示删掉权值边的个数。同时,push的判定条件,也由原来的一个变成了两个,一个是在ktime不变的情况下是否push,另一个是在ktime+1的情况下是否push。这样就可以完美地构建出二维数组的 dis[n][m]
了。最后在寻找
a
n
s
ans
ans 时,只需要遍历 dis[T]
即可。
代码:
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
typedef long long ll;
#define INF 1e9 + 5
int n, m, S, T, k;
ll dis[maxn][maxn];
struct Edge
{
int from, to, dist;
Edge(int u,int v,int d):from(u),to(v),dist(d){}
};
struct HeapNode{
int d, u, ktime;
bool operator<(const HeapNode &rhs) const
{
return d > rhs.d;
}
};
struct Dijkstra
{
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn][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(Edge(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s){
memset(dis, INF, sizeof(dis));
priority_queue<HeapNode> Q;
dis[s][0] = 0;
memset(done, 0, sizeof(done));
Q.push((HeapNode){0, s, 0});
while (!Q.empty())
{
HeapNode x = Q.top();
Q.pop();
int u = x.u;
int ktime = x.ktime;
if (done[u][ktime])
continue;
done[u][ktime] = true;
for (int i = 0; i < G[u].size();i++){
Edge &e = edges[G[u][i]];
if(dis[u][ktime]+e.dist<dis[e.to][ktime]){
dis[e.to][ktime] = dis[u][ktime] + e.dist;
Q.push((HeapNode){dis[e.to][ktime], e.to, ktime});
}
if(ktime<k&&dis[u][ktime]<dis[e.to][ktime+1]){
dis[e.to][ktime + 1] = dis[u][ktime];
Q.push((HeapNode){dis[e.to][ktime + 1], e.to, ktime + 1});
}
}
}
}
};
int main(){
scanf("%d%d%d%d%d", &n, &m, &S, &T, &k);
Dijkstra dij;
dij.init(n);
int a, b, l;
for (int i = 0; i < m; i++)
{
scanf("%d%d%d", &a, &b, &l);
dij.AddEdge(a, b, l);
dij.AddEdge(b, a, l);
}
dij.dijkstra(S);
ll ans = INF;
for (int i = 0; i <= k; i++)
{
ans = (ans < dis[T][i]) ? ans : dis[T][i];
}
printf("%lld", ans);
return 0;
}