最短路 (超详细大全)
最短路
文章目录
-
- 最短路
-
- 最短路
- Floyd算法
- 朴素版dijkstra
- 堆优化版的dijkstra
- 有边数限制的最短路(bellman-ford)
- spfa求最短路
- spfa判断负环
最短路
朴素的dijkstra使用邻接矩阵来存储
堆优化的dijkstra使用优先队列和邻接链表来存储
bellman_ford使用结构体来存储边的信息+memcpy数组,对k条边进行松弛操作
spfa是bellman_ford的优化使用队列+邻接链表
floyd使用邻接矩阵进行存储+暴力遍历
Floyd算法
该算法是一种在具有正或负边缘权重（但没有负环）的加权图中找到最短路径的算法，即支持负权值但不支持负权环。
Floyd求最短路
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。
数据保证图中不存在负权回路。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。
输出格式
共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。
数据范围
1≤n≤200
1≤k≤n^2
1≤m≤20000
图中涉及边长绝对值均不超过 10000。
输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1
AC思想
AC代码
#include
#include
#include
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]);//k在最外层
}
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;
}
朴素版dijkstra
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n≤500,
1≤m≤105,
图中涉及边长均不超过10000。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
AC思路
因为存在重边所以在存放数据时需要判断重复边的权值,然后取一个较小的权值;
因为是稠密图(边多点少的情况),所以直接采用邻接矩阵来存储数据;
然后时间复杂度是n^2(n是点数);
算法思路: 定义一个二维数组用来存储数据(g[N][N]);然后申请一个一维数组用来存放每一个点到达第一个点的距离;最后需要一个bool数组用来标记是否出现过;
AC代码
#include
#include
#include
using namespace std;
const int N = 510;
int g[N][N];
int dis[N];
bool vis[N];
int n,m;
int dijkstra(){
memset (dis,0x3f,sizeof dis);
dis[1] = 0;
for(int i = 0;i < n;++ i){
int t = -1;
for(int j = 1;j <= n;++ j){//从1号点开始
if(!vis[j]&&(t==-1||dis[t]>dis[j])){
t = j;
}
}
vis[t] = true;
for(int i = 1;i <= n;++ i){
dis[i] = min (dis[i],dis[t] + g[t][i]);
}
}
if(dis[n] == 0x3f3f3f3f) return -1;
return dis[n];
}
int main(){
cin>>n>>m;
memset (g,0x3f,sizeof g);
int x,y,z;
for(int i = 1;i <= m;++ i){
cin >> x >> y >> z;
g[x][y] = min(g[x][y],z);
}
cout << dijkstra() << endl;
return 0;
}
堆优化版的dijkstra
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n,m≤1.5×105,
图中涉及边长均不小于 00，且不超过 10000。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
AC思想
因为n和m的范围是1~1.5*105,大于105,所以朴素版的dijksta n^2的复杂度不能够满足,所以这种边和点成正比的关系需要用邻接表+优先队列进行优化处理
pair排序,优先对first进行排序,如果first相同则对second进行排序,通过对距离进行排序后,在前面的距离对应的点就是我们需要进行操作的点和距离
mlogn
AC代码
#include
#include
#include
#include
using namespace std;
typedef pairPII;
#define IOS std::ios::sync_with_stdio(false);std::cin.tie(0);
const int N = 1e6 + 10;
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dis[N];
bool vis[N];
void add(int a,int b,int c){
w[idx] = c;e[idx] = b;ne[idx] = h[a];h[a] = idx ++;
}
int dijkstra(){
memset(dis, 0x3f, sizeof dis);
dis[1] = 0;
priority_queue,greater >heap;
heap.push({0,1});//0是距离,1是结点号数
while(heap.size()){
auto t = heap.top();
heap.pop();
int distance = t.first,ver = t.second;
if(vis[ver]) continue;
vis[ver] = true;
for(int i = h[ver]; i!=-1; i = ne[i]){
int j = e[i];
if(dis[j]>dis[ver] + w[i]){
dis[j] = dis[ver] + w[i];
heap.push({dis[j],j});
}
}
}
if(dis[n] == 0x3f3f3f3f) return -1;
return dis[n];
}
int main(){
cin >> n >>m;
memset(h,-1,sizeof h);
while(m --){
int a,b,c;
cin >> a >> b >> c;
add(a, b, c);
}
cout << dijkstra() < 第二标尺:有多条路径相同时
在有两条路径相同时,需要再增加一条判断准则(第一准则是距离)
1.给每一条边加一个边权(花费),要求在最短路径有多条时要求路径上花费最小或最大
2.给没个点加一个点权,和边权一样问法
3.直接问有多少条最短路径
解题方法:
是增加一个数组存放新的边权或点权或做短路径条数,然后在算法中修改优化d[v]步骤
1.cost[u][v]表示u->v的花费,并增加一个数组c[],令从起点s到达顶点u的最少花费为c[u],初始时只有c[s]=0,其余都为INF
for (int v = 0; v < n;v++){//以u为中介开始优化到s的距离
if(vis[v]==false&&G[u][v]!=INF){
if(d[u]+G[u][v]2.weight[u]表示城市u的点权(题目输入),并增加一个数组w[],s到u的最大物资为w[u],初始化时只有w[s]为weight[s],其余w[u]均为0
for (int v = 0; v < n;v++){//以u为中介开始优化到s的距离
if(vis[v]==false&&G[u][v]!=INF){
if(d[u]+G[u][v]w[v]){
w[v]=w[u]+weight[v];
}
}
}
3.增加数组num[],s到u的最短路径条数为num[u],num[s]=1,其余num[u]=0;
for (int v = 0; v < n;v++){//以u为中介开始优化到s的距离
if(vis[v]==false&&G[u][v]!=INF){
if(d[u]+G[u][v]典例
#include
using namespace std;
const int inf=999999;
int weight[1010],e[1010][1010],dis[1010],rode[1010],w[1010];
bool visit[1010];
int main()
{
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,inf);
int n,m,c1,c2;
int a,b,c;
cin>>n>>m>>c1>>c2;
for(int i=0;i>weight[i];
}
for(int i=0;i>a>>b>>c;
e[a][b]=e[b][a]=c;
}
dis[c1]=0;
rode[c1]=1;
w[c1]=weight[c1];
for(int i=0;idis[u]+e[u][v]&&visit[v]==false){
dis[v]=dis[u]+e[u][v];
rode[v]=rode[u];//路径数
w[v]=w[u]+weight[v];//点的权重
}
else if(dis[v]==dis[u]+e[u][v]&&visit[v]==false){
rode[v]+=rode[u];
if(w[v] dijkstra+DFS:
在dijkstra中记录所有最短路径(只考虑距离),然后在这些最短路径中选出一条第二标尺最优的路径
1.使用dijkstra算法记录所有最短路径
要记录所有最短路径,因此每个节点都有多个前驱结点,则原来的pre数组只能记录一个前驱结点的方法就不在适用,可以设置vector,这样对于每一个结点,pre[v]就是一个边长数组vector,用来存放结点v的前驱结点
对于需要查询某个顶点u是否在顶点v的前驱中的题目,也可以把pre数组设置为set数组,此时可以使用pre[v].count(u)来查询
vectorpre[MAXV];
void dijkstra(int s){
fill(d, d + MAXV, INF);
d[s] = 0;
for (int i = 0; i < n;i++){
int u = -1, MIN = INF;
for (int j = 0; j < n;j++){
if(vis[j]==false&&d[j] 2.DFS遍历所有最短路径,找出一条第二标尺最优的路径
int optvalue;//第二标尺最优值optValue
vector pre[MAXV];//存放结点的前驱结点
vector path, temppath;//最优路径,临时路径
void DFS(int v){//v为当前访问结点
if(v==st){//递归边界,达到叶子节点,即路径的起点
temppath.push_back(v);//将起点st加入到临时路径最后面
int value;//存放临时路径的第二标尺的值
计算路径temppath的value值;
if(value优于optvalue){
optvalue = value;
path = temppath;//更新最优路径
}
temppath.pop_back();//删除刚加入的结点
return;
}
//递归式
temppath.push_back(v);//当前访问结点加入到临时路径最后面
for (int i = 0; i < pre[v].size();i++){
DFS(pre[v][i]);
}
temppath.pop_back();//遍历完所有前驱结点,将当前结点v删除
}
//边权之和
//三条边两个边权注意i的范围
int value=0;
for(int i=temppath.size()-1;i>0;i--){//倒序访问
int id=temppath[i],idnext=temppath[i-1];
value+=v[id][idnext];
}
//点权之和
//注意i的范围
int value=0;
for(int i=temppath.size()-1;i>=0;i--){
int id=temppath[i];
value+=w[id]
}
旅行地图给出了公路沿线城市之间的距离，以及每条公路的成本。现在，您应该编写一个程序来帮助旅行者确定从出发城市到目的地之间的最短路径。如果这样的最短路径不是唯一的，则应该输出成本最低的路径，该路径保证是唯一的。
打印第二标尺的最短路径
#include
#include
using namespace std;
const int maxv = 510, INF = 0x7fffffff;
int G[maxv][maxv]; //各边距离
int d[maxv]; //源点到各顶点的最短路径
int w[maxv][maxv]; //各边花费
int cost[maxv]; //源点到各顶点的最小花费
bool vis[maxv] = {false};
int pre[maxv];
int n, m, st, des;
void Dijkstra(){
fill(d, d + maxv, INF);
fill(cost, cost + maxv, INF);
for(int i = 0; i < n; i++)
pre[i] = i;
d[st] = 0;
cost[st] = 0;
for(int i = 0; i < n; i++){
int u = -1, min = INF;
for(int j = 0; j < n; j++){ //找到最小d[u]
if(vis[j] == false && d[j] < min){
min = d[j];
u = j;
}
}
if(u == -1) return; //不连通
vis[u] = true;
for(int v = 0; v < n; v++){
if(G[u][v] != INF && vis[v] == false){
if(d[u] + G[u][v] < d[v]){
d[v] = d[u] + G[u][v];
cost[v] = cost[u] + w[u][v];
pre[v] = u;
}
else if(d[u] + G[u][v] == d[v]
&& cost[u] + w[u][v] < cost[v]){
cost[v] = cost[u] + w[u][v];
pre[v] = u;
}
}
}
}
}
void DFS(int v){
if(v == st){ //到达起点
printf("%d", st);
return;
}
DFS(pre[v]);
printf(" %d", v);
}
int main(){
scanf("%d%d%d%d", &n, &m, &st, &des);
fill(G[0], G[0] + maxv * maxv, INF);
int u, v;
for(int i = 0; i < m; i++){
scanf("%d%d", &u, &v);
scanf("%d%d", &G[u][v], &w[u][v]);
G[v][u] = G[u][v];
w[v][u] = w[u][v];
}
Dijkstra();
DFS(des);
printf(" %d %d", d[des], cost[des]);
return 0;
}
有边数限制的最短路(bellman-ford)
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
数据范围
1≤n,k≤500,
1≤m≤10000,
任意边长的绝对值不超过 10000。
输入样例：
3 3 1
1 2 1
2 3 1
1 3 3
输出样例：
3
AC思路
因为边权有负数,所以不能使用dijksta算法,因为有边数限制所以只能使用bellman-ford算法,因为存在负权回路,但是有边数的限制,所以不会造成死循环,但是最后dis[n]可能不会等于0x3f3f3f3f;注意最后的判断条件;
o(mn)的时间复杂度
算法思路:就是遍历k次,每一次都要遍历所有边,并用选取出来的到结点1的最短距离进行更新,然后找到最短距离;;;(暴力) 所以直接用结构体进行边的存储
AC代码
#include
#include
#include
using namespace std;
const int N = 510, M = 10010;
struct Edge
{
int a, b, c;
}edges[M];
int n, m, k;
int dist[N];
int last[N];
void bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;//第一个点的距离为0
for (int i = 0; i < k; i ++ )//限制的k条边,就是从中选择k次
{
memcpy(last, dist, sizeof dist);//备份一下,每次在前一次的基础上更新
for (int j = 0; j < m; j ++ )//每一次选边都要遍历m条边(也就是所有的边)
{
auto e = edges[j];//等于第j条边
dist[e.b] = min(dist[e.b], last[e.a] + e.c);//e.a是存放的是连接这个点的上一个点
}
}
}
int main()
{
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i ++ )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edges[i] = {a, b, c};
}
bellman_ford();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");//小心有负权回路
else printf("%d\n", dist[n]);
return 0;
}
spfa求最短路
SPFA:判定负权回路,处理负权边的最短路问题
bfs思想判断负环:如果不存在负权边,则不需要num数组
spfa+队列优化+链式前向星+打印最短路径
#include
#include
#include
#include
#include
using namespace std;
typedef long long ll;
typedef pair P;
const int Maxn = 5e5 + 10;
const int INF = 1e9;
struct Node{
int to, w, Next;
}e[Maxn];
int n, k;
ll dis[Maxn],path[Maxn];
ll head[Maxn], cnt;
ll num[Maxn];
void init(){
cnt = 0;
memset(head, -1, sizeof(head));
memset(num,0 sizeof(num));
memset(path, -1, sizeof(path));
}
void addEdge(int u, int v, int w){
e[cnt].to = v;
e[cnt].w = w;
e[cnt].Next = head[u];
head[u] = cnt++;
}
void Spfa(){
priority_queue, greater > que;
for (int i = 1; i <= k; i++) dis[i] = INF;
que.push(make_pair(0, 1));
dis[1] = 0;
while (!que.empty()){
P now = que.top();
que.pop();
int s = now.second;
for (int i = head[s]; i != -1; i = e[i].Next){
int v = e[i].to;
int w = e[i].w;
if (dis[v] > dis[s] + w){
dis[v] = dis[s] + w;
path[v] = s;
que.push(make_pair(dis[v], v));
}
}
}
}
vector ve;
int getAns (int k){
int ans = 0;
for ( ; k != -1; k = path[k]) {
ve.push_back(k);
}
reverse(ve.begin(), ve.end());
return ve.size();
}
int main (){
cin >> n >> k;
init();
int u, v;
for (int i = 0; i < n; i++){
cin >> u >> v;
addEdge(u, v, 1);
}
Spfa();
int ans = getAns(k);
if (dis[k] == INF) cout << -1 << endl ;
else{
cout << ans << endl;
for (int i = 0; i < ans; i++) cout << ve[i] << endl ;
}
return 0;
}
spfa判断负环
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
如果图中存在负权回路，则输出 Yes，否则输出 No。
数据范围
1≤n≤2000,
1≤m≤10000
图中涉及边长绝对值均不超过 10000。
输入样例：
3 3
1 2 -1
2 3 4
3 1 -4
输出样例：
Yes
AC思想
根据抽屉原理,如果边数比点数多,则存在负环
然后需要判断每一个出发是否存在负环
AC代码
#include
#include
#include
#include
using namespace std;
const int N = 2010, M = 10010;
int n, m;
int h[N], w[M], e[M], ne[M], idx;
int dist[N], cnt[N];
bool vis[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 q;
// 这里不需要初始化dist数组为 正无穷。不用初始化的原因是， 如果存在负环， 那么dist不管初始化为多少， 都会被更新
for (int i = 1; i <= n; i ++ ){
vis[i] = true;
q.push(i);
}
while (q.size()){
int t = q.front();
q.pop();
vis[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[j] >= n) return true;//抽屉原理,一定有回路
if (!vis[j]){
q.push(j);
vis[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;
}