代码随想录第42天：图论3

一、字符串接龙（Kamacoder　110）

1.思路：

在无权图中，用广搜求最短路最为合适，广搜只要搜到了终点，那么一定是最短的路径。因为广搜就是以起点中心向四周扩散的搜索。

from collections import deque# 判断两个字符串是否只差一个字符
def is_one_letter_diff(s1, s2):return sum(c1 != c2 for c1, c2 in zip(s1, s2)) == 1# 广度优先搜索，寻找最短变换路径
def bfs(start, end, word_list):if start == end:return 0  # 起点就是终点，步数为 0n = len(word_list)visited = [False] * n  # 记录哪些字符串已经访问过queue = deque()queue.append((start, 1))  # 初始节点和步数为 1（因为要从 start 开始变换）while queue:current_word, steps = queue.popleft()  # 取出队头元素# 如果当前字符串和目标只差一位，表示下一步就能变成目标if is_one_letter_diff(current_word, end):return steps + 1# 遍历所有未访问过的中间词for i in range(n):if not visited[i] and is_one_letter_diff(current_word, word_list[i]):visited[i] = Truequeue.append((word_list[i], steps + 1))  # 入队下一步return 0  # 无法转换到目标字符串# 主程序入口
if __name__ == '__main__':n = int(input())  # 输入字符串个数start_word, end_word = input().split()  # 输入起点和终点word_list = [input().strip() for _ in range(n)]  # 输入字符串列表result = bfs(start_word, end_word, word_list)print(result)

sum(c1 != c2 for c1, c2 in zip(s1, s2)) == 1

这是一个生成器表达式，逐对比较两个字符串对应字符是否不同，返回布尔值序列,Python 中 True == 1，False == 0，所以 sum() 会统计有多少个字符不同：

s1 = "abc"
s2 = "adc"
zip(s1, s2)  → [('a','a'), ('b','d'), ('c','c')]
返回布尔值序列：
['a' != 'a' → False,'b' != 'd' → True,'c' != 'c' → False]
Python 中 True == 1，False == 0，所以 sum() 会统计有多少个字符不同：sum([False, True, False]) → 1

当然也可以改写为更直观方式：

def is_one_letter_diff(s1, s2):count = 0for c1, c2 in zip(s1, s2):if c1 != c2:count += 1return count == 1

2.带路径追踪写法

我们可以在原有 BFS 基础上，追加路径追踪功能，在队列中不仅记录当前字符串和步数，还记录当前路径的历史节点列表。

queue.append((当前字符串, 当前步数, [路径上的字符串们]))

from collections import deque# 判断两个字符串是否只差一个字符
def is_one_letter_diff(s1, s2):return sum(c1 != c2 for c1, c2 in zip(s1, s2)) == 1# 广度优先搜索：寻找最短路径并打印变换路径
def bfs(start, end, word_list):if start == end:print(0)print(start)returnn = len(word_list)visited = [False] * n  # 记录哪些字符串已经访问过queue = deque()queue.append((start, 1, [start]))  # 包含路径的队列节点while queue:current_word, steps, path = queue.popleft()# 如果下一步就可以达到目标，直接输出路径if is_one_letter_diff(current_word, end):print(steps + 1)print(" -> ".join(path + [end]))returnfor i in range(n):if not visited[i] and is_one_letter_diff(current_word, word_list[i]):visited[i] = Truequeue.append((word_list[i], steps + 1, path + [word_list[i]]))print(0)  # 无法到达目标# 主程序入口
if __name__ == '__main__':n = int(input())  # 中间字符串数量start_word, end_word = input().split()  # 起点和终点word_list = [input().strip() for _ in range(n)]bfs(start_word, end_word, word_list)

输出结果示例：

4
abc -> dbc -> dec -> def

二、有向图的完全可达性（Kamacoder　105）

import collections  
# 广度优先搜索：从起点 start 出发，遍历整个图，返回所有可达节点的集合
def bfs(start, graph):visited = set()        # 记录访问过的节点，防止重复访问que = collections.deque([start])    # 使用 deque 实现高效队列，初始加入起点while que:node = que.popleft()    # 取出队首节点if node in visited:continuevisited.add(node)        # 记录当前节点为已访问# 遍历当前节点的所有可达节点for cur in graph[node]:que.append(cur)        # 将邻居节点加入队列等待访问return visited# 主函数：读取输入、建图、执行 BFS，并判断所有节点是否可达
def main():n, k = map(int, input().split())# 使用 defaultdict 初始化图的邻接表结构graph = collections.defaultdict(list) for _ in range(k):src, dest = map(int, input().split())graph[src].append(dest)        # 构建有向图（从 src 指向 dest）visited_nodes = bfs(1, graph)        # 从节点 1 出发执行 BFS，获取所有可达节点# 如果访问到的节点刚好是 1~N，说明所有节点都可以从 1 号访问到if visited_nodes == set(range(1, n + 1)):return 1else:return -1if __name__ == "__main__":print(main())

三、寻找存在的路径（Kamacoder　107）

当我们需要判断两个元素是否在同一个集合里的时候，就要想到用并查集。

并查集主要有两个功能：

• 将两个元素添加到一个集合中。

• 判断两个元素在不在同一个集合

# 并查集（Union-Find）结构定义
class UnionFind:def __init__(self, size):# 初始化父节点数组，初始每个节点的父亲是自己self.parent = list(range(size + 1))  def find(self, u):# 查找 u 的根节点（带路径压缩优化）if self.parent[u] != u:# 递归查找根节点，并压缩路径（使中间所有节点直接指向根）self.parent[u] = self.find(self.parent[u])  return self.parent[u]def union(self, u, v):# 合并 u 和 v 所在集合root_u = self.find(u)root_v = self.find(v)if root_u != root_v:# 将 v 的根节点挂到 u 的根节点上（实现合并）self.parent[root_v] = root_udef is_same(self, u, v):# 判断 u 和 v 是否属于同一集合return self.find(u) == self.find(v)def main():import sysinput = sys.stdin.read  # 读取整个标准输入（适合大数据量的评测输入）data = input().split()  # 按空格/换行切分为字符串列表index = 0n = int(data[index])    # 读取节点个数 nindex += 1m = int(data[index])    # 读取边数 m（union 操作数）index += 1uf = UnionFind(n)       # 初始化并查集结构（节点从 1 到 n）# 处理 m 次 union 操作，代表 m 条边for _ in range(m):s = int(data[index])    # 每条边的起点index += 1t = int(data[index])    # 每条边的终点index += 1uf.union(s, t)          # 合并两个节点所在的集合# 读取要判断的两个节点source = int(data[index])index += 1destination = int(data[index])# 判断两节点是否在同一集合if uf.is_same(source, destination):print(1)  # 同一集合，输出 1else:print(0)  # 不同集合，输出 0

四、冗余连接（Kamacoder　１０８）

# 用于存储每个节点的父节点（并查集结构）
father = list()# 查找某个节点的根节点（带路径压缩）
def find(u):if u == father[u]:return uelse:# 路径压缩：让 u 直接指向根节点father[u] = find(father[u])return father[u]# 判断两个节点是否属于同一个集合（即是否已经连通）
def is_same(u, v):u = find(u)v = find(v)return u == v# 将两个节点所属的集合合并
def join(u, v):u = find(u)v = find(v)if u != v:father[u] = v  # 将 u 的根指向 v 的根（合并）# 主程序入口
if __name__ == "__main__":# 输入节点个数（注意：这题通常默认节点编号从 1 开始）n = int(input())# 初始化并查集数组（0 ~ n），每个节点的父亲先设为自己for i in range(n + 1):father.append(i)result = None  # 存放第一条构成环的边（即答案）# 依次读入 n 条边for i in range(n):s, t = map(int, input().split())  # 边的两个端点if is_same(s, t):# 如果两个端点已经在一个集合中，说明成环result = str(s) + ' ' + str(t)else:# 否则就合并两个集合join(s, t)# 输出成环的边print(result)