代码随想录训练营 Day53打卡 图论part04 110. 字符串接龙 105. 有向图的完全可达性 106. 岛屿的周长

代码随想录训练营 Day53打卡 图论part04

一、卡码110. 字符串接龙

本题与力扣127题是一样的，所以这里使用力扣127题。

字典 wordList 中从单词 beginWord 到 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s₁ -> s₂ -> … -> s_k：
    每一对相邻的单词只差一个字母。
     对于 1 <= i <= k 时，每个 s_i 都在 wordList 中。注意， beginWord 不需要在 wordList 中。
    s_k == endWord
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回 从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。
示例 ：
输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
输出：5
解释：一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”, 返回它的长度 5。

从这个图中可以看出 abc 到 def的路线 不止一条，但最短的一条路径上是4个节点。

1. 建立映射和标号：

• 目的：为了方便表示单词及其关系，我们需要为每个单词分配一个唯一的 ID。
• 操作：将 beginWord 和 wordList 中的所有单词都加入到一个映射中，称为wordId。通过哈希表的方式，将每个单词映射到它的 ID。
• 无解检查：如果 endWord 不在这个映射中，则直接返回无解，因为没有路径可以到达目标。

2. 优化建图：

• 朴素思路的不足：如果直接枚举每一对单词并判断它们是否仅差一个字符，这种方法在处理较大规模的单词表时效率太低，时间复杂度为 O(N² * L)，其中 N 是单词数，L 是单词长度。

• 虚拟节点优化：
  – 核心思想：引入虚拟节点来减少建图的复杂度。
  – 虚拟节点的创建：对于每个单词 word，我们用通配符 * 替换单词的每个字符。例如，单词 hit 对应的虚拟节点是 * it、h * t、hi *。
  – 连接规则：每个单词都会向它对应的虚拟节点连接，即该单词和虚拟节点之间互相连通。如果两个单词通过某个虚拟节点连接，那么它们必然可以通过一次字符替换相互转换。

3. 广度优先搜索 (BFS)：

• BFS的意义：在图中寻找从 beginWord 到 endWord 的最短路径。

• 队列初始化：将起始单词加入 BFS 队列，开始广度优先搜索。

• 终止条件：一旦我们搜索到终点 endWord，则说明我们找到了最短路径。

4. 距离的调整：

• 双倍距离：由于我们引入了虚拟节点，因此路径的长度会比实际的多一倍。每次经过一个虚拟节点到另一个单词节点，会增加 2 个单位的距离。

• 最终结果：我们实际的最短路径长度应为距离的一半，再加 1（因为起点要计入路径中）。

总结：

• 通过虚拟节点的引入，我们将原先 O(N²) 的判断复杂度降低到了 O(N * L)，因为每个单词的虚拟节点数量为
  L，即单词的长度，这样在遍历的时候仅需要处理相邻的虚拟节点。
• 广度优先搜索保证我们找到的路径是最短的。
• 返回值需要经过调整来反映真实的最短路径长度。

代码实现

class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        
        # 辅助函数，用于为一个单词添加唯一ID
        def addWord(word: str):
            if word not in wordId:  # 如果单词还没有记录
                nonlocal nodeNum  # 使用nonlocal表示要修改外部作用域中的变量
                wordId[word] = nodeNum  # 将单词与其ID关联
                nodeNum += 1  # 每添加一个新单词，增加ID的数量
        
        # 辅助函数，用于建立单词之间的连接
        # 将每个单词的一个字符替换为通配符 "*"，然后将该通配符单词与原单词连接
        def addEdge(word: str):
            addWord(word)  # 先为这个单词添加一个唯一ID
            id1 = wordId[word]  # 获取该单词的ID
            chars = list(word)  # 将单词转换为字符数组
            for i in range(len(chars)):  # 遍历单词中的每个字符
                tmp = chars[i]  # 记录原字符
                chars[i] = "*"  # 替换该字符为通配符 "*"
                newWord = "".join(chars)  # 形成新的"通配符"单词
                addWord(newWord)  # 给这个通配符单词添加唯一ID
                
                id2 = wordId[newWord]  # 获取通配符单词的ID
                edge[id1].append(id2)  # 将原单词的ID和通配符单词的ID连接起来
                edge[id2].append(id1)  # 反向连接，保证是无向图
                
                chars[i] = tmp  # 恢复原来的字符

        wordId = dict()  # 创建一个字典，用于存储每个单词及其唯一ID
        edge = collections.defaultdict(list)  # 创建邻接表，存储每个单词的邻居
        nodeNum = 0  # 用于给每个单词分配唯一的节点编号

        # 为字典中的每个单词建立图中的边
        for word in wordList:
            addEdge(word)
        
        addEdge(beginWord)  # 为起始单词添加边
        if endWord not in wordId:  # 如果目标单词不在字典中，无法转换
            return 0
        
        # 初始化最短距离数组，初始值为无穷大
        dis = [float("inf")] * nodeNum
        beginId, endId = wordId[beginWord], wordId[endWord]  # 获取起点和终点单词的ID
        dis[beginId] = 0  # 起点单词的距离初始化为0

        # BFS队列，初始化时将起始单词的ID加入队列
        que = collections.deque([beginId])
        while que:
            x = que.popleft()  # 从队列中取出当前处理的单词ID
            if x == endId:  # 如果当前单词ID就是目标单词的ID，说明找到了最短路径
                return dis[endId] // 2 + 1  # 返回实际的步数（每次步进都是2个节点，所以除以2加1）
            for it in edge[x]:  # 遍历当前单词的所有邻接单词
                if dis[it] == float("inf"):  # 如果该单词还未被访问过
                    dis[it] = dis[x] + 1  # 更新到该单词的最短距离
                    que.append(it)  # 将该单词加入队列，继续BFS
        
        return 0  # 如果没有找到转换路径，返回0

力扣题目链接
题目文章讲解

二、卡码105. 有向图的完全可达性

题目描述
给定一个有向图，包含 N 个节点，节点编号分别为 1，2，…，N。现从 1 号节点开始，如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。
输入描述
第一行包含两个正整数，表示节点数量 N 和边的数量 K。 后续 K 行，每行两个正整数 s 和 t，表示从 s 节点有一条边单向连接到 t 节点。
输出描述
如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。
输入示例
4 4
1 2
2 1
1 3
2 4
输出示例
1
提示信息

从 1 号节点可以到达任意节点，输出 1。

本题是一个有向图搜索全路径的问题。为了判断是否可以从 1 号节点到达图中的所有节点，可以使用深度优先搜索（DFS）。我们只需从节点 1 开始，通过 DFS 遍历所有可以到达的节点，最后检查是否所有节点都被访问过。如果所有节点都被访问过，输出 1；否则，输出 -1。

1. 图的构建： 我们使用邻接表来表示图，其中 graph[i] 表示从节点 i 出发可以到达的所有节点列表。
2. DFS 遍历： 定义了一个递归的 dfs 函数，从 1 号节点开始，递归遍历所有可以到达的节点，并标记它们为已访问。
3. 检查是否能访问所有节点：在 DFS 结束后，检查 visited 数组是否所有节点（从 1 到 N）都被标记为 True，如果是，表示可以到达所有节点，返回 1，否则返回 -1。
4. 时间复杂度：由于我们遍历了所有节点和所有边，时间复杂度为 O(N + K)，即节点数和边数的总和。

代码实现

def can_reach_all_nodes(N, edges):
    # 构建图的邻接表表示
    graph = [[] for _ in range(N + 1)]  # 使用邻接表存储有向图
    for s, t in edges:
        graph[s].append(t)  # 从节点 s 到节点 t 的有向边

    # 标记每个节点是否被访问过
    visited = [False] * (N + 1)

    def dfs(node):
        # 深度优先搜索函数
        visited[node] = True  # 标记当前节点已访问
        for neighbor in graph[node]:
            if not visited[neighbor]:  # 如果相邻节点未访问，继续递归
                dfs(neighbor)

    # 从节点 1 开始 DFS
    dfs(1)

    # 检查是否所有节点都被访问过（忽略 0 号节点）
    if all(visited[1:]):
        return 1  # 如果所有节点都能访问，返回 1
    else:
        return -1  # 否则返回 -1

# 输入读取
N, K = map(int, input().split())  # 读取节点数量 N 和边的数量 K
edges = [tuple(map(int, input().split())) for _ in range(K)]  # 读取 K 条边

# 输出结果
print(can_reach_all_nodes(N, edges))

卡码题目链接
题目文章讲解

三、卡码106. 岛屿的周长

题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。
你可以假设矩阵外均被水包围。在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出一个整数，表示岛屿的周长。
输入示例
5 5
0 0 0 0 0
0 1 0 1 0
0 1 1 1 0
0 1 1 1 0
0 0 0 0 0
输出示例
14
提示信息

岛屿的周长为 14。

基本思路是遍历每个陆地格子并检查它的四个方向，判断该方向是否为边界或水域。如果是，则将该边计入周长贡献。

1. dx 和 dy：这两个列表用于表示四个方向的偏移量，分别是右、下、左、上。dx 表示行的变化，dy 表示列的变化。
2. n 和 m：分别是网格的行数和列数。
3. 双重循环遍历：遍历网格的每一个格子，检查是否为陆地格子（值为 1）。
4. 四个方向检查：对于每一个陆地格子，检查它的上下左右四个方向是否越界或是水域（值为 0）。如果是，则该方向会为周长贡献 1。
5. 周长计算：每当找到一条边是边界或水域，就将 cnt 增加 1，最后将 cnt 加到总的周长 ans 中。

代码实现

class Solution:
    # 定义四个方向，分别为右、下、左、上
    dx = [0, 1, 0, -1]
    dy = [1, 0, -1, 0]

    def islandPerimeter(self, grid: list[list[int]]) -> int:
        n, m = len(grid), len(grid[0])  # 获取网格的行数和列数
        ans = 0  # 用于记录周长
        
        # 遍历每个格子
        for i in range(n):
            for j in range(m):
                if grid[i][j] == 1:  # 如果是陆地
                    cnt = 0
                    # 检查四个方向
                    for k in range(4):
                        tx = i + self.dx[k]
                        ty = j + self.dy[k]
                        # 如果该方向越界或者是水域
                        if tx < 0 or tx >= n or ty < 0 or ty >= m or grid[tx][ty] == 0:
                            cnt += 1
                    ans += cnt  # 将该格子的周长贡献加入总周长

        return ans

卡码题目链接
题目文章讲解