基础图论的一点理解

最新推荐文章于 2024-10-30 16:52:01 发布
最新推荐文章于 2024-10-30 16:52:01 发布
阅读量256 收藏 2
点赞数 4
分类专栏： 图论 文章标签： 图论 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73146523/article/details/128904138
版权
本文详细介绍了图的两种存储方式——邻接表和邻接矩阵，以及如何使用它们来存储有向图和无向图。接着讨论了拓扑排序的实现方法和最短路问题，包括Floyd算法和Dijkstra算法的实现细节，同时提供了代码示例和相关题目链接，帮助理解这些算法的工作原理和应用场景。
摘要由CSDN通过智能技术生成

文章目录

有向图

一般g存图、dis存边权、u起点、v终点、w边权、s是包含定点的集合

无向图

无向图就是特殊的有向图，一遍存图存 " 存两遍 "

邻接表

存出边和边权的二维列表或者字典（一般是列表，因为大部分题目以从1开始的编号作为结点，如果用字典存要浪费一部分空间，而列表这部分空间用索引实现即可），如果是无向图一对就要添加两次

用二维列表存code

n, m = map(int, input().split())
g = [[] for _ in range(n+1)]
for _ in range(m):
    u, v, w = map(int, input().split())
    g[u].append((v, w))
    g[v].append((u, w))  # 有向图这句不要

特点

优：节省空间，在只要遍历某点的出边时很方便

缺：无法快速查找两个点之间的边权

邻接矩阵

用二维列表存边权

code

dis = [[float('inf')]*(n+1) for _ in range(n+1)]
for _ in range(m):
    u, v, w = map(int, input().split())
    dis[u][v] = w
    dis[v][u] = w  # 有向图这句不要

特点

优：可以很方便的查找两个顶点间的边权，可以O(1)时间添加和删除边

缺：会浪费空间（要提前占满二维空间，即提前把空间开好）

拓扑排序

拓扑排序主要用来解决有向图中的依赖解析（dependency resolution）问题。

也可以用来找出环（先拓扑排序，因为环上的入度都比较大，拓扑排序在后面，dfs或bfs剩下来的就是环）

实现方法

  1. 把入度为0的挑出来，把他们的出边的入度-1
  2. 不断把入度为0的挑出来，就是拓扑排序的结果

题目传送门

P4017 最大食物链计数 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

code

n, m = map(int, input().split())
d = dict(zip(range(1, n+1), ([0, []] for _ in range(n))))
for _ in range(m):
    a, b = map(int, input().split())
    d[b][0] += 1  # 入度+1
    d[a][1].append(b)  # 出边+1
in1 = [(i, j) for i, j in d.items() if j[0] == 0]
out = [i for i, j in d.items() if j[1] == []]
c = []
dp = [0]*(n+1)
for i, j in in1:
    dp[i] = 1
    for k in j[1]:
        d[k][0] -= 1  # 入度-1
        dp[k] = (dp[k] + dp[i]) % 80112002
        if not d[k][0]:
            c.append((k, d[k]))
for i, j in c:
    for k in j[1]:
        d[k][0] -= 1  # 入度-1
        dp[k] = (dp[k]+dp[i]) % 80112002
        if not d[k][0]:
            c.append((k, d[k]))
ans = 0
for i in out:
    ans = (ans+dp[i]) % 80112002
print(ans)

最短路

在这里插入图片描述

Floyd算法

适用于多源最短路问题

初始化

code
f = [[0 if i == j else float('inf') for j in range(n)] for i in range(n)]

主体

标准code
for k in range(1, n+1):
    for i in range(1, n+1):
        for j in range(1, n+1):
            if f[i][j] > f[i][k]+f[k][j]:  # 避免多次调用函数
                f[i][j] = f[i][k]+f[k][j]
细节

  1. k必须在最外层：一是因为基本的逻辑是先只考虑直接连通问题，再把k一个一个添加进去算子图，所以为了保证每个k都是在遍历全图，k得在外循环；二是因为得确保

    f[i][k]和f[k][j]都是已经和前面的k更新过的，如果k在内循环会导致它们可能还没被前面的k松弛过

    可以说在计算时都是以k为基点的，把一个一个"中转站"加入去更新

    一句话，Floyd算法的本质是DP，而k是DP的阶段，因此要写最外面。

  2. i 和 j 的顺序无所谓，随意调换

标准优化code
for k in range(1, n+1):
    for i in range(1, n+1):
        if k ！= i:  # 中转站是自己是毫无意义的
            if f[i][k] == float('inf'):  # 跳过不可能的中转站
                continue
            for j in range(1, n+1):
                if f[i][j] > f[i][k]+f[k][j]:  # 避免多次调用函数
                    f[i][j] = f[i][k]+f[k][j]
无向图的优化code

因为无向图是对称的，所以可以优化。注意有向图千万不要只计算上三角或下三角

for k in range(1, n+1):
    for i in range(2, n+1):  # 给j留空间（实际f[1][1]为0已经初始化过了）
        if k ！= i:  # 中转站是自己是毫无意义的
            if f[i][k] == float('inf'):  # 跳过不可能的中转站
                continue
            for j in range(1, i):  # 到i就是对角线了，f[i][i]是0，初始化的时候就算过了
                if f[i][j] > f[i][k]+f[k][j]:  # 避免多次调用函数
                    f[i][j] = f[j][i] = f[i][k]+f[k][j]  # 初始就是相等的，如果有替换就一起换

题目传送门

B3647 【模板】Floyd 算法 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

code
n, m = map(int, input().split())
f = [[0 if i == j else float('inf') for j in range(n+1)] for i in range(n+1)]
for _ in range(m):
    u, v, w = map(int, input().split())
    f[u][v] = f[v][u] = w
for k in range(1, n+1):
    for i in range(2, n+1):
        if k != i:
            if f[i][k] != float('inf'):
                for j in range(1, i):
                    if f[i][j] > f[i][k]+f[k][j]:
                        f[i][j] = f[j][i] = f[i][k]+f[k][j]
for i in range(1, n+1):
    for j in range(1, n+1):
        print(f[i][j], end=' ')
    print()

迪杰斯特拉算法(Dijkstra)

适用于单源最短路问题，即一个点到所有点

优点：高效稳定。缺点：边权不能为负

思想：贪心+优先队列
在这里插入图片描述

如图，原本考虑s到u最短直连通路径就是8，但是因为负边权的存在最短路径变成了5，所以迪杰斯特拉算法(Dijkstra)算法不支持负边权

思维过程（类似bfs，也就是为什么不能出现负边权）

  1. 从源点u1开始下一个一定是源点的最短直联通点u2
  2. 再下一个一定是u2的最短直联通点或u1剩下的最短直联通点
  3. 每次加入的点将自己的直连通点加入排序，每次弹出最小的那个作为下一个源点

实现过程

  1. 从源点开始，将所有直联通点压入最小堆hp中
  2. 弹出里面路程最短的作为下一个源点
  3. 遍历下一个源点的还没加入路径的直联通点
  4. 如果能产生更优方案就压入最小堆，更高的优先级让最优的方案优先被弹出（原本的方案还在，不会消失）
  5. 因为一个点只要一个最优方案，所以加入路径后就直接用done标记，这样下次遍历时就会跳过这个

标准code

题目传送门

P4779 【模板】单源最短路径（标准版） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

import heapq


def dij(s, d):
    done = [0]*(n+1)
    hp = []
    heapq.heappush(hp, (0, s))  # （堆，（优先级，元素））
    while hp:
        u = heapq.heappop(hp)[1]  # 因为弹出的是元组，但是现在只要下一个顶点
        if done[u]:
            continue
        done[u] = 1
        for v, w in g[u]:
            if done[v]:
                continue
            if d[v] > d[u]+w:  # 第一次替换就是第一种能到的情况，会压入hp
                d[v] = d[u]+w
                heapq.heappush(hp, (d[v], v))  # 如果不换就说明到v的仍然是直通或之前留下来的方案快，而hp只留下一个点最快的方案，等这个点最快的方案最快了就弹出，如果没有发生替换


n, m, s0 = map(int, input().split())
g = [[] for _ in range(n+1)]
dis = [float("inf")]*(n+1)  # 存到源点的距离
dis[s0] = 0
for _ in range(m):
    u, v, w = map(int, input().split())
    g[u].append((v, w))
dij(s0, dis)
for i in range(1, n+1):
    print(dis[i], end = ' ')

输出源点到每点的路径code

import heapq


def dij(s, d, r):
    done = [0]*(n+1)
    hp = []
    r[1] = '1 '
    heapq.heappush(hp, (0, s))  # （堆，（优先级，元素））
    while hp:
        u = heapq.heappop(hp)[1]  # 因为弹出的是元组，但是现在只要下一个顶点
        if done[u]:
            continue
        done[u] = 1
        for v, w in g[u]:
            if done[v]:
                continue
            if d[v] > d[u]+w:  # 第一次替换就是第一种能到的情况，会压入hp
                d[v] = d[u]+w
                r[v] = r[u]+f"{v} "
                heapq.heappush(hp, (d[v], v))  # 如果不换就说明到v的仍然是直通或之前留下来的方案快，而hp只留下一个点最快的方案，等这个点最快的方案最快了就弹出，如果没有发生替换


n, m, s0 = map(int, input().split())
g = [[] for _ in range(n+1)]
dis = [float("inf")]*(n+1)  # 存到源点的距离
dis[s0] = 0
road = ["-1"]*(n+1)  # 不能到达输出-1
for _ in range(m):
    u, v, w = map(int, input().split())
    g[u].append((v, w))
    g[v].append((u, w))  # 做题一定注意单双
dij(s0, dis, road)
for i in range(1, n+1):
    print(road[i])

输出源点到某一点的最短路径

题目传送门

Dijkstra? - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

import heapq


def dij(s, d, r, k):
    done = [0]*(n+1)
    hp = []
    r[1] = '1 '
    heapq.heappush(hp, (0, s))  # （堆，（优先级，元素））
    while hp:
        u = heapq.heappop(hp)[1]  # 因为弹出的是元组，但是现在只要下一个顶点
        if u == k:
            print(r[k])
            return
        if done[u]:
            continue
        done[u] = 1
        for v, w in g[u]:
            if done[v]:
                continue
            if d[v] > d[u]+w:  # 第一次替换就是第一种能到的情况，会压入hp
                d[v] = d[u]+w
                r[v] = r[u]+f"{v} "
                heapq.heappush(hp, (d[v], v))  # 如果不换就说明到v的仍然是直通或之前留下来的方案快，而hp只留下一个点最快的方案，等这个点最快的方案最快了就弹出，如果没有发生替换


n, m, s0, key = map(int, input().split())
g = [[] for _ in range(n+1)]
dis = [float("inf")]*(n+1)  # 存到源点的距离
dis[s0] = 0
road = [""]*(n+1)
for _ in range(m):
    u, v, w = map(int, input().split())
    g[u].append((v, w))
    g[v].append((u, w))
dij(s0, dis, road)
if dis[k] == float('inf'):
    print(-1)

变式

题目传送门

P1576 最小花费 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

import heapq


def dij(s, d, k):
    done = [0]*(n+1)
    hp = []
    heapq.heappush(hp, (1, s))  # （堆，（优先级，元素））
    while hp:
        u = heapq.heappop(hp)[1]  # 因为弹出的是元组，但是现在只要下一个顶点
        if u == k:
            print('%.8f' % (100*d[k]))
            return
        if done[u]:
            continue
        done[u] = 1
        for v, w in g[u]:
            if done[v]:
                continue
            if d[v] > d[u]/w:  # 第一次替换就是第一种能到的情况，会压入hp
                d[v] = d[u]/w
                heapq.heappush(hp, (d[v], v))  # 如果不换就说明到v的仍然是直通或之前留下来的方案快，而hp只留下一个点最快的方案，等这个点最快的方案最快了就弹出，如果没有发生替换


n, m = map(int, input().split())
g = [[] for _ in range(n+1)]
dis = [float("inf")]*(n+1)  # 存到源点的距离
for _ in range(m):
    u, v, w = map(int, input().split())
    w = 1-w/100
    g[u].append((v, w))
    g[v].append((u, w))
a, b = map(int, input().split())
dis[a] = 1
dij(a, dis, b)
陈子昂-北工大
关注
专栏目录
OI学习笔记之图论基础知识
Hoyoak的博客
08-09 1058
图论基础知识 没有用的话qaq : Ummmm…图论的大部分知识本来早就有学过，只是一直没有写成博文来梳理，但既然上了qbxt DP图论就写一篇来总结下，主要是来听图论的，但…由于太菜的原因，DP听得天花乱坠QWQ 一，图：图是边和点组成的几何体 G=< V , E > V是点集合，E是边集 形如这样的东西就是一个图 二，图的相关基本概念 1，边：图上连接点和点之间的东西叫做边...
【离散数学】图论基础知识
热门推荐
fjtooo的博客
06-27 5万+
文章目录1.数据结构部分2.离散数学部分2.1 图的基本概念2.2 图的连通性2.3 图的矩阵表示2.4 几种特殊的图2.4.1 二部图2.4.2 欧拉图2.4.3 哈密顿图2.4.4 平面图2.5 无向树2.6 生成树 1.数据结构部分 2.离散数学部分 2.1 图的基本概念 无向图： 简而言之，边不带方向的图就是无向图。 有向图： 简而言之，边带方向的图就是有向图。 特殊定义： 有限图：...
图论基础算法
csdnwqy030429的博客
01-23 3381
图论基础问题图的存储与遍历拓扑排序最短路算法最小生成树二分图 图的存储与遍历 拓扑排序 最短路算法 最小生成树 二分图
5.图论.基础1
weixin_43831098的博客
08-05 1086
个人根据代码随想录刷题的思路和笔记整理
图论基础
QAQ_QwQ_QAQ的博客
10-28 1024
引子：图论是数学的一个分支，它以图为研究对象。然而信息学中的图论是以图为基础，重点是代码。。。[借助图主要是方便理解和计算]。 正文部分： 一、线的分类：        1、自环：一条边的两个端点是重合的。        2、重边：两个端点之间有两条以上的边。        3、就是那种很一般的线段（记不得什么学术性名称了= =）。 附：旁边下面的图（1）就是拥有一般线段的简单图，
图论基础与遍历算法
2302_76853832的博客
07-23 1278
图论基础及图的DFS遍历
【数据结构】图论基础
2301_79969994的博客
10-02 2258
通过本篇文章的介绍，我们初步了解了图的基本概念、图的表示方法（如邻接矩阵和邻接表）、以及图中的各种基本性质。图论作为计算机科学和数学中的一个重要分支，其应用范围广泛，从网络设计到路径规划，都有着广泛的应用场景。在接下来的学习中，我们可以进一步探讨更高级的图算法，如最短路径算法（Dijkstra、Bellman-Ford 等）、图的遍历算法（深度优先搜索、广度优先搜索）、以及图的连通性和最小生成树等高级主题。这些内容将为解决更复杂的实际问题提供坚实的理论基础。
01图论基础
Edward_Legend的博客
11-17 1738
什么是图 图的基本示意图 图是描述复杂事务的数据表示形式，由节点和边组成，数学上一般表述为 图G-（V，E）。其中的V（vertical）代表节点，可被理解为事物。 而E（edge）代表边，描述的是两个事物之间的关系。例如一个图的社交网络图，每个人都可视为节点，而人与人之间的关系可被视为边。 而在我们的推荐系统中，用户与物品之间的交互关系，用户与用户自身的关系，物品与物品之间的关系，完全可由一张图完整的进行描述。如下图所示： 用户与物品之间的关系图 无向图与有向图 无向图 有向图 双向图 无向图是由没有方
jnu第一大混子的训练纪录3：基础图论和基础数论
qq_51567843的博客
11-04 456
Part 1 ：图论 （接训练纪录2 part 3） 图的着色问题 泛指把图的相邻顶点染成不同颜色的问题，没有深究，以简单题为例：洛谷2819 #include<iostream> #include<algorithm> #include<cmath> #include<cstdio> #include<cstring> #include<vector> #include<queue> #include<ma
图论入门（完结）
cqbzliuhongyi的博客
10-12 9805
- 图的基本概念（已更） - 图的存储结构（邻接矩阵、邻接表、链式前向星）（已更） - 图的遍历（深度优先、广度优先）（已更） - 一笔画问题（欧拉回路，已更） - 哈密顿路问题（已更） - 最短路径（已更） - 最小生成树(已更)
图论基础ppt
07-27
### 图论基础知识详解 #### 一、图论概述 图论是数学的一个分支，主要研究图形的性质及其应用。在计算机科学中，图论被广泛应用于算法设计与分析、网络优化、数据库管理等多个领域。 #### 二、基本概念 1. **点...
实验5 图论（桥）_图论桥的定义_图论——桥问题_图论桥的定义_
09-28
图论是数学的一个分支，主要研究点...总的来说，图论中的桥问题是一个基础而重要的课题，它涉及到图的结构分析和连通性的研究。理解和应用桥的概念，能够帮助我们更好地解决与图相关的问题，尤其是在网络设计和优化中。
【代码随想录Day54】图论Part06
Shayne 的博客
10-27 359
【代码】【代码随想录Day54】图论Part06。
【代码随想录Day53】图论Part05
Shayne 的博客
10-27 341
【代码】【代码随想录Day53】图论Part05。
代码随想录（十二）——图论
m0_47411815的博客
10-27 395
并查集可以解决的问题：两个节点是否在一个集合，也可以将两个节点添加到一个集合中。中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为。请找出一条可以删去的边，删除后可使得剩余部分是一个有着。) 的树中添加一条边后的图。添加的边的两个顶点包含在。边连接，并且没有顶点存在与自身相连的边。如果有多个答案，则返回数组。图中的边用一个二维整数数组。难点在于根的路径压缩的理解。图，其中每个顶点标记从。请你确定是否存在从顶点。树可以看成是一个连通且。并查集主要有三个功能。
【代码随想录Day58】图论Part09
最新发布
Shayne 的博客
10-30 259
【代码】【代码随想录Day58】图论Part09。
【代码随想录Day55】图论Part07
Shayne 的博客
10-27 416
【代码】【代码随想录Day55】图论Part07。
2024 CSP-J 题解
ZXTpower的博客
10-27 917
​ 题目给出了一整套牌的定义，但是纯粹在扯淡，完全没有必要去判断给出的牌的花色和点数，我们用一个循环来依次读入每一张牌，如果这个牌在之前出现过，我们就让答案减一。这里建议用map、unordered_set或者给每一种牌一个编号，然后用数组存储也可以。
图论BFS
2301_81978634的博客
10-27 820
div2 的c题 使用数组转化成图论问题，找出节点最大值，因为其中的数值较大，使用map存储路径和访问节点，遍历时间复杂度为NlogN。
图论算法基础讲解
"图论算法入门，适合初学者的图论算法教程，由孙云龙主讲，内容涵盖数值计算...图论算法入门课程将引导初学者逐步理解图的理论基础，熟悉图的表示方法，并掌握利用图论解决实际问题的技能，是进入这个领域的良好起点。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈子昂-北工大

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值