文章目录
最短路:建图!
- 源点—起点
- 汇点—终点
- 约定n为点数,m为边数
1单源最短路:求一个点到其他所有点的最短路
1.1所有边权都是正数
(1)朴素的Dijkstra算法(On^2)
例题:Dijkstra求最短路 I
代码:
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 510;
int n,m;
int g[N][N];//邻接矩阵
int dist[N];//用于存储每个点到起点的最短距离
bool st[N];//xx点的最短距离已经确定了
int dijkstra()
{
//先把所有距离初始化为正无穷
memset(dist,0x3f,sizeof dist);//dist 数组的各个元素为无穷大
dist[1] = 0;//源点到源点的距离为置为 0,1号点
//迭代n次,每次可以确定一个点到起点的最短路
for(int i = 0;i < n;i++)
{
int t = -1;
//t的作用?
/*一开始t的赋值是-1
如果t没有被更新,
那么要更新一下t*/
//遍历所有点
for(int j = 1;j <= n;j++)//遍历 dist 数组,找到没有确定最短路径的节点中距离源点最近的点t
//不在s集合,并且
//如果没有更新过,则进行更新, 或者发现更短的路径,则进行更新
if(!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
//加入到s集合中
st[t] = true;
//找到了距离最小的点t,并用最小的点t去更新其他的点到起点的距离
for(int j = 1;j <= n;j++)//遍历 t 所有可以到达的节点 i
dist[j] = min(dist[j],dist[t] + g[t][j]);//更新 dist[j]
}
if(dist[n] == 0x3f3f3f3f) return -1;
//memset 按字节赋值,所以memset 0x3f 就等价与赋值为0x3f3f3f3f
return dist[n];
}
int main()
{
scanf("%d %d",&n,&m);
//初始化邻接矩阵
/*for(int i = 1;i <= n;i++)
for(int j = 1;j <= n;j++)
if(i == j) g[i][j] = 0;
else g[i][j] = INF;
*/
memset(g,0x3f,sizeof g);
//读入边
while(m--)
{
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
g[a][b] = min(g[a][b],c);//可能有重边,保留长度最短的边
}
int t = dijkstra();
printf("%d\n",t);
return 0;
}
(2)堆优化版的Dijkstra算法(Omlogn)
用堆对朴素版进行优化
例题:Dijkstra求最短路 II
#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()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
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;
}
1.1存在负权边
(1)Bellman–Ford O(nm)
Bellman - ford 算法是求含负权图的单源最短路径的一种算法,效率较低,代码难度较小。其原理为连续进行松弛,在每次松弛时把每条边都更新一下,若在 n-1 次松弛后还能更新,则说明图中有负环,因此无法得出结果,否则就完成。
(通俗的来讲就是:假设 1 号点到 n 号点是可达的,每一个点同时向指向的方向出发,更新相邻的点的最短距离,通过循环 n-1 次操作,若图中不存在负环,则 1 号点一定会到达 n 号点,若图中存在负环,则在 n-1 次松弛后一定还会更新)
注意:back[] 数组是上一次迭代后 dist[] 数组的备份,由于是每个点同时向外出发,因此需要对 dist[] 数组进行备份,若不进行备份会因此发生串联效应,影响到下一个点
注:不存在负权回路
例题:有边数限制的最短路
在下面代码中,是否能到达n号点的判断中需要进行if(dist[n] > INF/2)判断,而并非是if(dist[n] == INF)判断,原因是INF是一个确定的值,并非真正的无穷大,会随着其他数值而受到影响,dist[n]大于某个与INF相同数量级的数即可
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510, M = 10010;
struct Edge
{
int a, b, w;
}edges[M];
int n, m, k;
int dist[N], backup[N];
void bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < k; i ++)
{
memcpy(backup, dist, sizeof dist);
for (int j = 0; j < m; j ++)
{
auto v = edges[j];
dist[v.b] = min(dist[v.b], backup[v.a] + v.w);
}
}
}
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);
edges[i] = {a, b, w};
}
bellman_ford();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d\n", dist[n]);
return 0;
}
(2)SPFA 一般:O(m),最坏O(nm)
其实是对Bellman–Ford做了优化
基本思路:更新过谁,我就拿谁来更新别人
例题:spfa求最短路
#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 spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 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])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[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) puts("impossible");
else printf("%d\n", t);
return 0;
}
例题:spfa判断负环
#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],cnt[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 ++ ;
}
bool spfa()
{
queue<int> q;
//把所有点全部放入
for(int i = 1;i <= n;i++)
{
st[i] = true;
q.push(i);
}
while (q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1;
if(cnt[t] > n) return true;
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
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);
}
if(spfa()) puts("Yes");
else puts("No");
return 0;
}
2.多源汇最短路:起点和终点不确定
Flod算法 O(n^3)
初始为邻接矩阵,结束后为从i到j的最短路。
例题:Floyd求最短路
floyd本身是个动态规划算法,在代码实现的时候省去了一维状态。
原状态是:f[i, j, k]
表示从i
走到j
的路径上除了i, j
以外不包含点k
的所有路径的最短距离。那么f[i, j, k] = min(f[i, j, k - 1), f[i, k, k - 1] + f[k, j, k - 1
]。
因此在计算第k
层的f[i, j]
的时候必须先将第k - 1
层的所有状态计算出来,所以需要把k
放在最外层。
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
int d[N][N];
void floyd()
{
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
int main()
{
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
d[a][b] = min(d[a][b], c);
}
floyd();
while (Q -- )
{
int a, b;
scanf("%d%d", &a, &b);
int t = d[a][b];
if (t > INF / 2) puts("impossible");
else printf("%d\n", t);
}
return 0;
}