力扣热题100-图论4题

Love_ovo
141 阅读9分钟

🌊 图与字符串结构的4道经典题精讲：BFS、拓扑排序、Trie树一次掌握！

本文带你一次性掌握 LeetCode 中四道热门中等难度题目，涵盖 BFS 搜索、拓扑排序、字典树（Trie） 等核心算法思想。适合算法学习者与面试备战者参考~

🚩 1. 岛屿数量（Number of Islands）🌴

🔗 题目链接

描述

Difficulty: 中等

Related Topics: 深度优先搜索， 广度优先搜索， 并查集， 数组， 矩阵

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

示例 2：

输入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
输出：3

提示：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 300
  • grid[i][j] 的值为 '0' 或 '1'

✅ 解题思路：BFS/DFS 搜索连通块

给定一个二维地图，其中 '1' 表示陆地，'0' 表示水。我们要统计地图中 “岛屿” 的数量。

思路解析：

  • 将地图视为图，‘1’代表可通行的点。
  • 每遇到一个未访问的‘1’，就启动一次 BFS 或 DFS，将该块所有连通的陆地标记为已访问。
  • 每次启动搜索，岛屿数 +1。

💡 C++ 实现代码（使用 DFS | BFS）：

class Solution {
public:
    int vis[302][302];
    const int dx[4] = {0, 0, 1, -1};
    const int dy[4] = {1, -1, 0, 0};
    char Map[302][302];
    int n, m;

    void dfs(int x, int y) {
        vis[x][y] = 1;
        for (int i = 0; i < 4; i++) {
            int xx = x + dx[i], yy = y + dy[i];
            if (xx >= 0 && xx < n && yy >= 0 && yy < m && Map[xx][yy] == '1' && vis[xx][yy] == 0) {
                dfs(xx, yy);
            }
        }
    }

    int numIslands(vector<vector<char>>& grid) {
        int sum = 0;
        n = grid.size(), m = grid[0].size();
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                Map[i][j] = grid[i][j];

        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (Map[i][j] == '1' && !vis[i][j]) {
                    dfs(i, j);
                    sum++;
                }

        return sum;
    }
};

🍊 2. 腐烂的橘子（Rotting Oranges）

🔗 题目链接

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

  • 值 0 代表空单元格；
  • 值 1 代表新鲜橘子；
  • 值 2 代表腐烂的橘子。

每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。
示例 1： image.png

输入： grid = [[2,1,1],[1,1,0],[0,1,1]]
输出： 4

示例 2：

输入： grid = [[2,1,1],[0,1,1],[1,0,1]]
输出： -1
解释： 左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。

示例 3：

输入： grid = [[0,2]]
输出： 0
解释： 因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

提示：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 10
  • grid[i][j] 仅为 0、1 或 2

✅ 解题思路：多源 BFS 搜索

思路解析： 橘子腐烂是一个 “从多个点向外扩展” 的过程，适合使用 BFS 层次遍历 模拟时间传播。

  • 所有初始腐烂橘子视为 BFS 起点。
  • 每一轮扩散，更新周围新鲜橘子的腐烂时间。
  • 最终判断是否存在未腐烂的橘子，若有返回 -1，否则返回最大传播时间。

💡 C++ 实现代码：

class Solution {
public:
    int Map[12][12], ans[12][12];
    int n, m;
    const int dx[4] = {0, 0, -1, 1};
    const int dy[4] = {-1, 1, 0, 0};
    queue<pair<int, int>> q;

    void bfs(int a, int b) {
        q.push({a, b});
        ans[a][b] = 0;
        while (!q.empty()) {
            int x = q.front().first, y = q.front().second;
            q.pop();
            for (int i = 0; i < 4; i++) {
                int xx = x + dx[i], yy = y + dy[i];
                if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue;
                if (Map[xx][yy] == 1 && ans[x][y] + 1 < ans[xx][yy]) {
                    ans[xx][yy] = ans[x][y] + 1;
                    q.push({xx, yy});
                }
            }
        }
    }

    int orangesRotting(vector<vector<int>>& grid) {
        n = grid.size(), m = grid[0].size();
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++) {
                Map[i][j] = grid[i][j];
                ans[i][j] = INT_MAX;
            }

        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (grid[i][j] == 2)
                    bfs(i, j);

        int mx = 0;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (grid[i][j] == 1) {
                    if (ans[i][j] == INT_MAX) return -1;
                    mx = max(mx, ans[i][j]);
                }

        return mx;
    }
};

📚 3. 课程表（Course Schedule）

🔗 题目链接

描述

Difficulty: 中等

Related Topics: 深度优先搜索， 广度优先搜索， 图， 拓扑排序

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程  bi。

  • 例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。

示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。
这是不可能的。

提示：

  • 1 <= numCourses <= 105
  • 0 <= prerequisites.length <= 5000
  • prerequisites[i].length == 2
  • 0 <= ai, bi < numCourses
  • prerequisites[i] 中的所有课程对 互不相同

✅ 解题思路：拓扑排序判断有无环

本题目实质是一个 有向图是否有环 的判断问题。

思路解析：

  • 用入度数组记录每门课程的前置课程数量。
  • 将入度为0的课程入队，依次处理它们的后继课程，减少其入度。
  • 最终若能遍历所有课程（即课程数 == 拓扑序长度），说明无环。

💡 C++ 实现代码：

class Solution {
public:
    int ans[2003];
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>>v(20003, vector<int>());
        for(int i = 0; i < prerequisites.size(); i++){
            int l = prerequisites[i][0], r = prerequisites[i][1];
            v[r].push_back(l);
            ans[l]++;
        }
        queue<int>q;
        for(int i = 0; i < numCourses; i++){
            if(ans[i] == 0) q.push(i);
        }
        int sum = 0;
        while(!q.empty()){
            sum++;
            int x = q.front(); q.pop();
            for(int i = 0; i < v[x].size(); i++){
                ans[v[x][i]]--;
                if(ans[v[x][i]] == 0) q.push(v[x][i]);
            }
        }
        if(sum < numCourses) return false;
        return true;
    }
};

🔠 4. 实现 Trie（前缀树）

没学过的理解完题目后可以直接看本文最后的题解

🔗 题目链接

描述

Difficulty: 中等

Related Topics: 设计， 字典树， 哈希表， 字符串

（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

请你实现 Trie 类：

  • Trie() 初始化前缀树对象。
  • void insert(String word) 向前缀树中插入字符串 word 。
  • boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
  • boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：

输入
["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
输出
[null, null, true, false, true, null, true]

解释
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple");   // 返回 True
trie.search("app");     // 返回 False
trie.startsWith("app"); // 返回 True
trie.insert("app");
trie.search("app");     // 返回 True

提示：

  • 1 <= word.length, prefix.length <= 2000
  • word 和 prefix 仅由小写英文字母组成
  • insert、search 和 startsWith 调用次数 总计 不超过 3 * 10410^4次

✅ 解题思路：字典树（Trie Tree）

Trie 树是一种高效管理字符串集合的数据结构，适用于 前缀匹配、字符串查找 等场景。

思路解析：

  • 每个节点有 26 个子节点（对应 26 个英文字母）。
  • 插入字符串：按字符逐层构建节点，最后标记为结尾。
  • 查询字符串：逐层判断字符是否存在，是否为终点。

💡 C++ 实现代码：

class Trie {
private:
    bool isEnd;
    Trie* next[26];

public:
    Trie() {
        isEnd = false;
        for (int i = 0; i < 26; i++) next[i] = nullptr;
    }

    void insert(string word) {
        Trie* node = this;
        for (char ch : word) {
            int idx = ch - 'a';
            if (!node->next[idx]) node->next[idx] = new Trie();
            node = node->next[idx];
        }
        node->isEnd = true;
    }

    bool search(string word) {
        Trie* node = this;
        for (char ch : word) {
            int idx = ch - 'a';
            if (!node->next[idx]) return false;
            node = node->next[idx];
        }
        return node->isEnd;
    }

    bool startsWith(string prefix) {
        Trie* node = this;
        for (char ch : prefix) {
            int idx = ch - 'a';
            if (!node->next[idx]) return false;
            node = node->next[idx];
        }
        return true;
    }
};

Trie 树详解笔记（附示例图解）

🌳 什么是 Trie？

Trie（又叫前缀树）是一种非典型的多叉树结构，它常用于处理字符串集合，尤其适用于：

  • 字符串查找
  • 前缀匹配
  • 自动补全功能

🧠 为什么说 Trie 是“非典型”的多叉树？

我们先来看一下普通多叉树的结点结构：

struct TreeNode {
    VALUETYPE value;               // 结点值
    TreeNode* children[NUM];       // 指向孩子结点的指针数组
};

每个结点中显式保存一个值，并通过 children 指针数组指向多个子节点。

而 Trie 树的结构就不太一样。以只处理小写英文字母 'a' ~ 'z' 为例，Trie 的结点设计如下：

struct TrieNode {
    bool isEnd;            // 是否为某个字符串的结尾
    TrieNode* next[26];    // 字母映射表（最多 26 个分支）
};

🔍 区别在哪？

Trie 的每个结点不直接保存字符本身，而是通过数组 next[26] 中的下标来隐式表示字符路径。

也就是说，字符是通过路径推断出来的，而不是写在结点里！

🧩 字母映射表的妙用

你可能会好奇：结点中都没存字符，那我怎么知道有哪些分支呢？

这时候 next[26] 数组就派上用场了。我们可以通过如下代码判断一个父结点能否连接到某个字符：

for (int i = 0; i < 26; i++) {
    char ch = 'a' + i;
    if (parentNode->next[i] == NULL) {
        // 父结点的后一个字符不能是 ch
    } else {
        // 父结点的后一个字符可以是 ch
    }
}

所以，路径上的字符信息是通过数组索引反推的，比如 next[0] 就表示 'a'，next[25] 表示 'z'。

📌 举个例子

我们构造一个包含以下单词的 Trie 树：

  • "sea"
  • "sells"
  • "she"

下面是这些单词在 Trie 中的结构（简化版图示）：

image.png
Trie 中一般都含有大量的空链接，因此在绘制一棵单词查找树时一般会忽略空链接，同时为了方便理解我们可以画成这样：

image.png

  • sea 路径是：s → e → a（结尾）
  • sells 路径是：s → e → l → l → s（结尾）
  • she 路径是：s → h → e（结尾）

结尾的结点都会设置 isEnd = true，用于标记这是一个完整的字符串。

avatar
文章
阅读
粉丝