图论（学习笔记）

原创已于 2023-03-31 19:54:48 修改 · 639 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #学习 #python

于 2023-03-31 19:54:12 首次发布

蓝桥杯专栏收录该内容

10 篇文章

订阅专栏

问题	边权	算法	时间复杂度
一个起点，一个终点	非负数；无边权（或边权为1）	A*	< O((m+n)logn)
		双向广搜	< O((m+n)logn)
		贪心最优搜索	< O(m+n)
一个起点到其他所有点	无边权（或边权为1）	BFS	O(m+n)
	非负数	Dijkstra(堆优化优先队列)	O((m+n)logn)
	允许有负数	SPFA	< O(mn)
所有点对之间	允许有负数	Floyd-Warshall	O(n3)

3 Floyd算法

动态规划：求图上两点i、j之间的最短距离，按“从小图到全图”的步骤，在逐步扩大图的过程中计算和更新最短路。

定义状态：dp[k][i][j]，i、j、k是点的编号，范围1 ~ n。状态dp[k][i][j]表示在包含1 ~ k点的子图上，点对i、j之间的最短路。

状态转移方程：从子图1 ~ k-1扩展到子图1 ~ k dp[k][i][j] = min(dp[k-1][i][j], dp[k-1][i][k] + dp[k-1][k][j])

dp[k][i][j] = min(dp[k-1][i][j], dp[k-1][i][k] + dp[k-1][k][j])

虚线圆圈：包含1 ~ k-1点的子图。 dp[k-1][i][j]：虚线子图内的点对i、j的最短路； dp[k-1][i][k] + dp[k-1][k][j]：经过k点的新路径的长度，即这条路径从i出发，先到k，再从k到终点j。

比较：不经过k的最短路径dp[k-1][i][j]和经过k的新路径，较小者就是新的dp[k][i][j]。

用滚动数组简化： dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])

Floyd
for k in range(1,n):
  for i in range(1,n):
    for j in range(1,n):
      dp[i][j] = min(dp[i][j], dp[i][k]+dp[k][j])

Floyd算法有个特点：能判断负圈。

负圈：若图中有权值为负的边，某个经过这个负边的环路，所有边长相加的总长度也是负数，这就是负圈。在这个负圈上每绕一圈，总长度就更小，从而陷入在负圈上兜圈子的死循环。

Floyd算法很容易判断负圈，只要在算法运行过程出现任意一个dp[i][i] < 0就说明有负圈。因为dp[i][i]是从i出发，经过其他中转点绕一圈回到自己的最短路径，如果小于零，就存在负圈。

题目：蓝桥公园

题目描述

小明喜欢观景，于是今天他来到了蓝桥公园。

已知公园有 N 个景点，景点和景点之间一共有 M 条道路。小明有 Q 个观景计划，每个计划包含一个起点 st 和一个终点 ed，表示他想从 st 去到 ed。但是小明的体力有限，对于每个计划他想走最少的路完成，你可以帮帮他吗？

输入描述

输入第一行包含三个正整数 N,M,Q

第 2 到M+1 行每行包含三个正整数 u,v,w，表示 u↔v 之间存在一条距离为 w 的路。

第 M+2 到 M+Q−1 行每行包含两个正整数 st,ed，其含义如题所述。

1≤N≤400，1≤M≤N×(N−1)/2，Q≤10^3，≤u,v,st,ed≤n，1≤w≤10^9

输出描述

输出共 Q 行，对应输入数据中的查询。

若无法从 st 到达 ed 则输出 −1。

输入输出样例

示例 1

输入

输出

1
3
2

import sys
INF = 0x3f3f3f3f3f3f3f3f
N = 405
dp = [[INF for j in range(N)] for i in range(N)]

def floyd():
    global dp
    for k in range(1, n+1):
        for i in range(1, n+1):
            for j in range(1, n+1):
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])

n, m, q = map(int, input().split())
for i in range(1, m+1):
    u, v, w = map(int, input().split())
    dp[u][v] = dp[v][u] = min(dp[u][v], w)

floyd()

for i in range(q):
    s, t = map(int, input().split())
    if dp[s][t] == INF:
        print("-1")
    elif s == t:
        print("0")
    else:
        print(dp[s][t])

4 Dijstra 算法

Dijkstra算法算是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其他所有点的最短距离

Dijkstra算法应用了贪心算法的思想，即“抄近路走，肯定能找到最短路径”。

每次往队列中放新数据时，按从小到大的顺序放，采用小顶堆的方式，复杂度是O(logn)，保证最小的数总在最前面；找最小值，直接取B的第一个数，复杂度是O(1)。

复杂度：用优先队列时，Dijkstra算法的复杂度是O(mlogn)，是最高效的最短路算法。

算法实现：

维护两个集合：已确定最短路径的结点集合A、这些结点向外扩散的邻居结点集合B。

（1）把起点s放到A中，把s所有的邻居放到B中。此时，邻居到s的距离就是直连距离。

（2）从B中找出距离起点s最短的结点u，放到A中。

（3）把u所有的新邻居放到B中。显然，u的每一条边都连接了一个邻居，每个新邻居都要加进去。其中u的一个新邻居v，它到s的距离dis(s, v)等于dis(s, u) + dis(u, v)。

（4）重复(2)、(3)，直到B为空时，结束。

题目：蓝桥王国

题目描述

小明是蓝桥王国的王子，今天是他登基之日。

在即将成为国王之前，老国王给他出了道题，他想要考验小明是否有能力管理国家。

题目的内容如下：

蓝桥王国一共有 N 个建筑和 M 条单向道路，每条道路都连接着两个建筑，每个建筑都有自己编号，分别为1∼N 。（其中皇宫的编号为 1）

国王想让小明回答从皇宫到每个建筑的最短路径是多少，但紧张的小明此时已经无法思考，请你编写程序帮助小明回答国王的考核。

输入描述

输入第一行包含三个正整数 N,M。

第 2 到M+1 行每行包含三个正整数 u,v,w，表示 u→v 之间存在一条距离为 w 的路。

1≤N≤3×105，1≤m≤10^6，1≤ui,vi≤N，0≤wi≤10^9。

输出描述

输出仅一行，共 N 个数，分别表示从皇宫到编号为1∼N 建筑的最短距离，两两之间用空格隔开。（如果无法到达则输出 −1）

输入输出样例

示例 1

输入

输出

0 1 3

题解：

Python
import heapq

INF = 0x3f3f3f3f3f3f3f3f
N = 300002

class Edge:
    def __init__(self, fr, to, w):
        self.fr = fr
        self.to = to
        self.w = w

class SNode:
    def __init__(self, id, n_dis):
        self.id = id
        self.n_dis = n_dis
    
    def __lt__(self, other):
        return self.n_dis < other.n_dis

def print_path(s, t):
    if s == t:
        print(s, end=" ")
        return
    print_path(s, pre[t])
    print(t, end=" ")

def dijkstra():
    s = 1
    done = [False] * N
    dis = [INF] * N
    pre = [-1] * N
    dis[s] = 0
    pq = []
    heapq.heappush(pq, SNode(s, dis[s]))
    while pq:
        u = heapq.heappop(pq)
        if done[u.id]:
            continue
        done[u.id] = True
        for y in e[u.id]:
            if done[y.to]:
                continue
            if dis[y.to] > y.w + u.n_dis:
                dis[y.to] = y.w + u.n_dis
                heapq.heappush(pq, SNode(y.to, dis[y.to]))
                pre[y.to] = u.id
    for i in range(1, n+1):
        if dis[i] >= INF:
            print("-1", end=" ")
        else:
            print(dis[i], end=" ")

n, m = map(int, input().split())
e = [[] for _ in range(N)]
for i in range(m):
    u, v, w = map(int, input().split())
    e[u].append(Edge(u, v, w))

dijkstra()

5 Bellman-ford算法

单源最短路径问题：给定一个起点s，求它到图中所有n个结点的最短路径。

问题引入：问路

图中每个点上站着一个“警察”。每个警察问邻居：走你这条路能到s吗？有多远？反复问多次，最后所有警察都能得到最短路。

第1轮，给所有n个人每人一次机会，问他的邻居，到s的最短距离是多少？更新每人到s的最短距离。特别地，在s的直连邻居中，有个t，得到了到s的最短距离。（注意，算法并没有查找是哪个t）

第2轮，重复第1轮的操作。更新每人到s的最短距离。特别地，在s和t的直连邻居中，有个v，得到了到s的最短距离。

第3轮，……

关于算法复杂度

一共需要几轮操作？每一轮操作，都至少有一个新的结点得到了到s的最短路径。所以，最多只需要n轮操作，就能完成n个结点。在每一轮操作中，需要检查所有m个边，更新最短距离。所以，Bellman-Ford算法的复杂度：O(nm)。

但是这个算法有个致命的缺点：进行了很多重复而且无用的计算

所以我们对这个算法进行了更新

我们计算结点u之后，下一步只计算和调整它的邻居，能加快收敛的过程，可以用队列对这个过程进行计算

改进后的算法称为：

6 SPFA算法

步骤：

（1）起点s入队，计算它所有邻居到s的最短距离。把s出队，状态有更新的邻居入队，没更新的不入队。

（2）现在队列的头部是s的一个邻居u。弹出u，更新它所有邻居的状态，把其中有状态变化的邻居入队列。

（3）继续以上过程，直到队列空。这也意味着，所有结点的状态都不再更新。最后的状态就是到起点s的最短路径。

题目：随机数据下的最短路问题

题目描述

给定 N 个点和 M 条单向道路，每条道路都连接着两个点，每个点都有自己编号，分别为 1∼N 。

问你从 S 点出发，到达每个点的最短路径为多少。

输入描述

输入第一行包含三个正整数N,M,S。

第 2 到 M+1 行每行包含三个正整数 u,v,w，表示 u→v 之间存在一条距离为 w 的路。

1≤N≤5×10^3，1≤M≤5×10^4，1≤ui,vi≤N，0≤wi≤10^9。

本题数据随机生成。

输出描述

输出仅一行，共 N 个数，分别表示从编号 S 到编号为 1∼N 点的最短距离，两两之间用空格隔开。（如果无法到达则输出 −1）

输入输出样例

示例 1

输入

输出

0 1 3

题解：

INF = 0x3f3f3f3f3f3f3f3f
N = 5010

class Edge:
    def __init__(self, to, w):
        self.to = to
        self.w = w

dist = [INF] * N
inq = [0] * N
e = [[] for _ in range(N)]

def spfa(s):
    global dist
    global inq
    dist = [INF] * N
    dist[s] = 0
    q = []
    heapq.heappush(q, s)
    inq[s] = 1
    while q:
        u = heapq.heappop(q)
        inq[u] = 0
        if dist[u] == INF:
            continue
        for i in range(len(e[u])):
            v = e[u][i].to
            w = e[u][i].w
            if dist[v] > dist[u] + w:
                dist[v] = dist[u] + w
                if inq[v] == 0:
                    heapq.heappush(q, v)
                    inq[v] = 1

n, m, s = map(int, input().split())
for i in range(m):
    u, v, w = map(int, input().split())
    e[u].append(Edge(v, w))
spfa(s)
for i in range(1, n+1):
    if dist[i] == INF:
        print("-1", end=" ")
    else:
        print(dist[i], end=" ")