图论 最短路

已于 2023-04-24 16:35:05 修改
阅读量72 收藏 1
点赞数 1
分类专栏： 蓝桥杯 文章标签： c++ 算法 Powered by 金山文档
于 2023-03-07 10:03:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72720964/article/details/129339729
版权

y总：n 表示点数 m表示边数

  • 最短路： memset(d,0x3f,sizeof d); INF = 0x3f3f3f3f;

  • 图的储存：稀疏图 邻接表，稠密图 邻接矩阵 （n^2 与 m 的数量级）

  • TLE时考虑 各种初始化 memset(dist,0x3f,sizeof dist);

用邻接表时一定要先初始化 memset(h,-1,sizeof h);

  • 无向图 g[a][b] = g[b][a] = min(g[a][b],c); add(b,a,c); 注意：e[ ]、ne[ ]、w[ ] 数组范围多开一倍

  • 互相比对来理解加深

dijkstra

  1. 朴素版dijkstra

#include <bits/stdc++.h>

using namespace std;

const int N = 1010,INF = 0x3f3f3f3f;

int n,m,sx,sy;
int g[N][N],dist[N];
bool st[N];

int dijkstra() // S集合：已确定的从sx点出发到点的距离是最短的
{
    memset(dist,0x3f,sizeof dist); 
    dist[sx] = 0; // 以某个点作为出发点
                        // 如果 下面就会再次 赋为 true  Segmentation Fault
    //st[1] = true; （错误）  第一次 必定是 t = 1  因为 dist[1] = 0 
    
    for(int i = 0;i < n;i++) // 迭代n个点 
    {
        int t = -1;
        for(int j = 1;j <= n;j++) // 遍历 不在 S集合中的距离最小的点
          if(!st[j] && (t == -1 || dist[j] < dist[t]))
           t = j; // 找到距 t 最近的点
        
        st[t] = true; // 将 t 加入 S集合中(当前已确定最短距离的点)
        
        for(int j = 1;j <= n;j++)
          dist[j] = min(dist[j],dist[t] + g[t][j]); // 用 t 更新
    }                          // 与 堆优化版  distance 相比对
    
    return d[sy];
}

int main()
{
    cin >> n >> m >> sx >> sy;
    
    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;
    
    for(int i = 0;i < m;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        g[a][b] = min(g[a][b],c); // 如果无向图 直接增加 g[b][a] = min(g[b][a],c);
    }                             //    或者 g[a][b] = g[b][a] = min(g[a][b],c);
    
    int t = dijkstra();
    if(t == 0x3f3f3f3f) cout << "-1" << endl;
    else cout << t << endl;
    
    return 0;
}

  1. 堆优化版dijkstra

#include <bits/stdc++.h>

using namespace std;

typedef pair<int,int> PII;
const int N = 1010,INF = 0x3f3f3f3f,M = 20010;
                                      // 1000 * 2 + 10
int n,m,sx,sy;
int h[N],e[M],ne[M],idx,w[M];
int dist[N];
bool st[N];
priority_queue<PII,vector<PII>,greater<PII>> heap;

void add(int a,int b,int c)
{
    w[idx] = c;
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}

int dijkstra()
{
    memset(dist,0x3f,sizeof dist); 
    dist[sx] = 0;
    heap.push({0,sx}); // first为距离  second为节点
                       // 强调 先后顺序不能变  first second
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        int distance = t.first,ver = t.second;
                               // 同朴素版的 S集合 
        if(st[ver]) continue; // 此处直接调过该节点  所以下面的if 不能加
        st[ver] = true;
        
        for(int i = h[ver];i != -1;i = ne[i])
        {
            int j = e[i];                 // w[i] i 是不断迭代的ne[i]  对应储存的 idx
            if(dist[j] > distance + w[i]) // 注： 此处 if判断不能加 (!st[j] &&  )
            {
                dist[j] = distance + w[i];
                heap.push({dist[j],j});
            }
               
            
        } 
    }
    
    return dist[sy];
}

int main()
{
    cin >> n >> m >> sx >> sy;
    
    memset(h,-1,sizeof h);
    
    for(int i = 0;i < m;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        add(a,b,c); // 如果是 无向图  add(a,b,c); add(b,a,c);
    }
    
    int t = dijkstra();
    if(t == INF) cout << "-1" << endl;
    else cout << t << endl;
    
    return 0;
}
bellman_ford 
#include <bits/stdc++.h>

using namespace std;

const int N = 510,INF = 0x3f3f3f3f,M = 10010;

struct Edge
{
    int x,y,c;
}tu[M];

int n,m,k,sx,sy;
int dist[N],backup[N];

int bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[sx] = 0;
    
    for(int i = 0;i < k;i++) // 遍历k条边  最多不超过k条边
    {
        memcpy(backup,dist,sizeof dist); 

        for(int j = 0;j < m;j++) // 每个边都遍历一遍 
        {
            int a = tu[j].x,b = tu[j].y,w = tu[j].c;
            if(dist[b] > backup[a] + w) // 同dijkstra相对比来理解
               dist[b] = backup[a] + w; // 用点a来更新点b
        }
    }
    
    return dist[sy];
}

int main()
{
    cin >> n >> m >> k >> sx >> sy;
    
    for(int i = 0;i < m;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        tu[i] = {a,b,c};
    }
    
    int t = bellman_ford();
    if(t > INF / 2) cout << "-1" << endl; // 如果存在负权边 无法到达 可能不是INF
    else cout << t << endl;
    
    return 0;
}
spfa

  1. 最短路

#include <bits/stdc++.h>

using namespace std;

const int N = 1010,INF = 0x3f3f3f3f,M = 20010;

int n,m,sx,sy;
int h[N],e[M],ne[M],idx,w[M];
int dist[N];
bool st[N];
queue<int> q;

void add(int a,int b,int c)
{
    w[idx] = c;
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}

int spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[sx] = 0;
    q.push({sx});
    st[sx] = true;
    
    while(q.size())
    {
        auto 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]; // 发生重复加入之前会被st[]数组判掉
                if(!st[j])               //  因为 更新距离在if(!st[j])之上 不会加入队列 但如果距离较小的话 仍然会被更新
                {
                    st[j] = true;
                    q.push({j});
                }
            }
        }
    }
    
    return dist[sy];
}

int main()
{
    cin >> n >> m >> sx >> sy;
    
    memset(h,-1,sizeof h);
    
    for(int i = 0;i < m;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        add(a,b,c); add(b,a,c);
    }
    
    int t = spfa();
                                        // 注意此处对于 不存在路径的判断 
    if(t == INF) cout << "-1" << endl; // 因为每次更新都是用之前已经更新过的节点 如果不存在负环则不考虑其它情况
    else cout << t << endl; 
    
    return 0;
}

  1. 判断是否存在负环

#include <bits/stdc++.h>

using namespace std;

const int N = 2010,M = 10010;

int h[N],e[M],ne[M],idx,w[M];
int dist[N],cnt[N],n,m;
bool st[N];
queue<int> q;

void add(int a,int b,int c)
{
    w[idx] = c;
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}

bool spfa()
{
    //memset(dist,0x3f,sizeof dist);  注: 理解 不需要初始化 及相应下面距离的更新
    //dist[1] = 0;
    for(int i = 1;i <= n;i++)
    {
        q.push(i);
        st[i] = 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];
                cnt[j] = cnt[t] + 1;
                if(cnt[j] >= n) return true;
                if(!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
}

int main()
{
    memset(h,-1,sizeof h);
    
    cin >> n >> m;
    for(int i = 0;i < m;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        add(a,b,c);
    }
    
    if(spfa()) puts("Yes");
    else puts("No");
    
    return 0;
}
Floyd

ACWing 854.Floyd求最短路

#include <bits/stdc++.h>

using namespace std;

const int N = 210,INF = 1e9;

int g[N][N],n,m;

void floyd()
{
    for(int k = 1;k <= n;k++) // k <= n 
      for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
          g[i][j] = min(g[i][j],g[i][k] + g[k][j]);
}

int main()
{
    int T;
    scanf("%d %d %d",&n,&m,&T);
    
    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;
    
    while(m--)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        g[a][b] = min(g[a][b],c);
    }
    
    floyd();
    
    while(T--)
    {
        int x,y;
        scanf("%d %d",&x,&y);
        if(g[x][y] > INF / 2) puts("impossible");
        else printf("%d\n",g[x][y]);
    }
    
    return 0;
}
Optimus Code
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论最短路
10-27
### 图论中最短路径的基本概念及Dijkstra算法详解 #### 最短路径的最优子结构性质 最短路径问题是在图论中的一个经典问题，主要研究如何在一张图中找到两个节点之间的最短路径。最短路径问题根据起点的不同可以...
图论最短路方法详细介绍
07-25
在图论中，最短路问题是一个核心议题，主要涉及寻找两个或多个节点之间路径的最小代价。本文将详细介绍几种常见的最短路算法，包括Dijkstra算法、Dijkstra的堆优化、Floyd算法以及Bellman-Ford算法。 首先，...
C++ 图论之多源最短路（floyd算法：邻接矩阵版）
weixin_66767924的博客
01-06 568
邻接矩阵版floyd算法讲解！快来瞅瞅吧！
C++学习第六篇——最短路
SmallHedgehog的博客
04-07 1505
最短路是图论最重要的算法之一，也是算法难点。经过这篇的学习，你会发现你离成功就差一个最短路的距离。=.= 最短路是指，某个点到某个点之间的距离最短。 算法1：Dijkstra算法 迪杰斯特拉算法是很典型的单源最短路算法，而且时间复杂度较其他算法更低，唯一的缺点是无法判断含负权边的图的最短路。而且其仅能作为单源最短路，也就是一个起点、一个终点求最短。在开始前推荐大家先去看我的另一篇博客最小生成树其中...
C++图论 最短路问题总结
m0_62946761的博客
12-29 8897
C++ 图论关于最短路问题的总结，包括Dijkstra，Bellman_ford，spfa算法等。
图论最短路算法总结
Eleanore__的博客
07-21 464
1.1 朴素版dijkstra在学习这几个算法之前，我们首先要知道，这些算法是用来求最短路的，那什么是最短路呢，最短路就是，一个图中，一个点到另外一个点所经过边的权重之和最小的路径就是最短路。了解了这个之后，我们还要知道最短路问题分为单源最短路，求图中一个点到其他点的最短路；多元最短路，求图中任意两个点的最短路。在学习这几个算法之前，我们还要了解两个数据结构，邻接矩阵和邻接表，这两个都是用来描述图的，解释了图中顶点之间的关系。
[图论 最短路 spfa]分糖果
Minecraftwzy的博客
08-18 251
今天给大家讲解分糖果这道题目 思路 很简单,我们把小朋友看作点,两个小朋友在彼此身旁看作是一条无向图的路径,路径的权值为111。现在糖果ccc小朋友身上,让我们求出传给其他小朋友之后,吃完糖的最小时间。 求最小时间,也就是求出距离ccc点最远的点的最小距离。 很简单,这就是一个单源点最短路。我们可以运用spfaspfaspfa算法来解决。 代码 #include<iostream> #include<queue> #include<cstring> using name
数学建模学习笔记（七）——图论最短路问题
striveAgain丶的博客
08-08 2146
文章目录一、综述二、图论最短路问题三、几个简单的作图方法四、Dijkstra（迪杰斯特拉）算法五、Bellman-Ford算法六、总结 一、综述 本文主要根据图论的基本概念，介绍图论中常见的建模问题——最短路问题。同时，介绍了解决图论最短路问题的两种算法：Dijkstra（迪杰斯特拉）算法和Bellman-Ford（贝尔曼-福特）算法。 在此之前，需要具备基本的图论知识哦~~~ 二、图论最短路问题 图论最短路问题指的是在带权重的图中，求出一条从一点节点到另一个节点的路径，使这条路径上的权重之和最小。 三、几
图论——最短路
m0_64378422的博客
07-14 593
最短路
图论最短路训练
XihuDacuyu的博客
07-16 104
链接：POWER UP: Shortest Paths - Virtual Judge (vjudge.net)IJK题解：专题训练：最短路 (yuque.com)
图论最短路dijkstra算法.doc
05-06
图论最短路 Dijkstra 算法 图论最短路 Dijkstra 算法是计算图论中从一个节点到另一个节点的最短路径的经典算法。该算法于 1959 年由荷兰数学家 Edsger W. Dijkstra 首次提出，是一种常用的图论算法。 算法描述 ...
NOIP图论最短路.pptx
07-29
最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1342
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 663
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 427
Linux 内核编程 /proc 例子代码
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
最新发布
填坑之路
09-06 378
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
【C++ Primer Plus习题】9.1
qq_74047911的博客
09-02 310
【C++ Primer Plus习题】9.1
C/C++内存详解
2301_79181030的博客
09-03 1250
注意，对于数组，不会调用构造函数来初始化每个元素（除非元素类型是类类型且该类提供了默认构造函数），而是进行默认初始化（对于类类型，调用默认构造函数；，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。对于自定义类型的对象，例如类对象，new对象的同时会调用构造函数对对象进行构造，delete对象的同时会调用析构函数对对象进行析构。操作符用于在堆（heap）上动态分配内存，并调用对象的构造函数（如果有的话）。
图论最短路python
07-27
- *2* [数学建模：图论模型 — 最短路模型示例 (Python 求解)](https://blog.csdn.net/qq_55851911/article/details/124776487)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值