BFS on Hang Zhang

Level of Point in Graph

Wed, 02 Apr 2025 00:00:00 +0000

图中点的层次

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环

所有边的长度都是 1，点的编号为 1 ∼ n

请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1

输入格式

第一行包含两个整数 n 和 m
接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离

数据范围

`1`	`1 ≤ n, m ≤ 105`

输入样例

输出样例

分析

邻接表存储：
- h[N]：存储每个节点的邻接链表的头节点（初始化为 -1）
- e[N]：存储邻接表中的边的目标节点
- ne[N]：存储邻接表中链表的下一个节点的索引
- idx：记录当前边的编号
add(a, b)：将一条从节点 a 到节点 b 的边加入邻接表中
bfs()：
- 初始化 d 数组为 -1，表示所有节点初始时不可达
- 从节点 1 开始进行 BFS，记录每个节点的最短路径
- 如果节点 n 被访问过，则返回 d[n]；否则返回 -1

时间复杂度

BFS 只会遍历每个节点和每条边一次，其中 n 是节点数，m 是边数

时间复杂度为 O(n + m)

空间复杂度

存储图的邻接表需要 O(n + m) 的空间
存储队列和距离数组需要 O(n) 的空间

空间复杂度为 O(n + m)

C++代码

#include <cstring>
#include <iostream>

const int N = 100010;  // 节点和边的最大数量

int h[N], e[N], ne[N], idx;  // 邻接表存储

int q[N];  // 队列
int d[N];  // 存储最短路径

int n, m;  // 节点数和边数

// 添加一条边到邻接表
void add(int a, int b)
{
  e[idx] = b;
  ne[idx] = h[a];
  h[a] = idx++;
}

// BFS 求最短路径
int bfs()
{
  int hh = 0, tt = 0;
  q[0] = 1;  // 起始节点 1

  std::memset(d, -1, sizeof(d));  // 初始化距离数组为 -1
  d[1] = 0;  // 起点到起点的距离为 0

  while (hh <= tt)  // 队列不为空
  {
    int t = q[hh++];  // 出队一个节点
    for (int i = h[t]; i != -1; i = ne[i])  // 遍历该节点的所有邻接节点
    {
      int j = e[i];  // 邻接节点 j
      if (d[j] == -1)  // 如果节点 j 尚未访问
      {
        d[j] = d[t] + 1;  // 更新节点 j 的距离
        q[++tt] = j;  // 将节点 j 加入队列
      }
    }
  }

  return d[n];  // 返回从 1 到 n 的最短路径长度
}

int main()
{
  std::cin >> n >> m;  // 输入节点数和边数

  std::memset(h, -1, sizeof(h));  // 初始化邻接表

  for (int i = 0; i < m; ++i)
  {
    int a, b;
    std::cin >> a >> b;  // 输入每条边
    add(a, b);  // 将边加入邻接表
  }

  std::cout << bfs() << '\n';  // 输出从 1 到 n 的最短距离

  return 0;
}

Digit 8

Tue, 01 Apr 2025 00:00:00 +0000

八数码

在一个 3 × 3 的网格中，1 ∼ 8 这 8 个数字和一个 x 恰好不重不漏地分布在这 3 × 3 的网格中

例如：

1
2
3

1 2 3
x 4 6
7 5 8

在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）

我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：

1
2
3

1 2 3
4 5 6
7 8 x

例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列

交换过程如下：

1
2
3

1 2 3   1 2 3   1 2 3   1 2 3
x 4 6   4 x 6   4 5 6   4 5 6
7 5 8   7 5 8   7 x 8   7 8 x

现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换

输入格式

输入占一行，将 3 × 3 的初始网格描绘出来
例如，如果初始网格如下所示：

1
2
3

1 2 3
x 4 6
7 5 8

则输入为：1 2 3 x 4 6 7 5 8

输出格式

输出占一行，包含一个整数，表示最少交换次数
如果不存在解决方案，则输出 −1

输入样例

`1`	`2 3 4 1 5 x 7 6 8`

输出样例

分析

抽象为 无权图的最短路径搜索，状态间转换是 交换 x 的位置

状态表示
- 使用字符串表示网格状态，目标状态：“12345678x”
状态转移
- x 可与 上下左右 相邻数交换
BFS 求最短步数
- 队列 q 记录待搜索的状态
- 哈希表 d 记录已访问状态，防止重复搜索
- BFS 逐层扩展
  - 取出队首状态 tmp
  - 遍历 x 的 4 个移动方向：
    - 生成新状态 next_state，如果未访问：
      - 记录步数 d[next_state] = d[tmp] + 1
      - 加入队列 q.push(next_state)
    - 若 tmp == end_state，返回步数
BFS 终止
- 如果队列为空，仍未找到解，则返回 -1（无解）

时间复杂度

时间复杂度 O(9!)

空间复杂度

空间复杂度为 O(9!)

C++代码

#include <iostream>
#include <queue>
#include <unordered_map>

int bfs(std::string& start_state)
{
  std::string end_state = "12345678x";  // 目标状态
  std::queue<std::string> q;  // BFS 队列
  std::unordered_map<std::string, int> d;  // 记录步数

  q.push(start_state);
  d[start_state] = 0;

  // 方向数组：右、下、左、上
  int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

  while (!q.empty())
  {
    std::string tmp = q.front();
    q.pop();

    int distance = d[tmp];  // 取当前状态的步数

    if (tmp == end_state)
      return distance;  // 目标状态，返回最小步数

    int k = tmp.find('x');  // 找到 'x' 的索引
    int x = k / 3, y = k % 3;  // 转换为二维坐标

    for (int i = 0; i < 4; ++ i)  // 遍历 4 个方向
    {
      int a = x + dx[i], b = y + dy[i];
      if (a >= 0 && a < 3 && b >= 0 && b < 3)  // 确保新位置合法
      {
        std::swap(tmp[k], tmp[a * 3 + b]);  // 交换 'x' 与相邻数字

        if (!d.count(tmp))  // 该状态未访问
        {
          q.push(tmp);  // 加入队列
          d[tmp] = distance + 1;  // 记录步数
        }

        std::swap(tmp[a * 3 + b], tmp[k]);  // 交换回来，恢复原状态
      }
    }
  }

  return -1;  // 无法到达目标状态
}

int main()
{
  std::string start_state;
  for (int i = 0; i < 9; ++ i)
  {
    char c;
    std::cin >> c;
    start_state += c;
  }

  std::cout << bfs(start_state) << '\n';

  return 0;
}

Walking Through the Maze

Tue, 01 Apr 2025 00:00:00 +0000

走迷宫

给定一个 n × m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁

最初，有一个人位于左上角 (1, 1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置

请问，该人从左上角移动至右下角 (n, m) 处，至少需要移动多少次

数据保证 (1, 1) 处和 (n, m) 处的数字为 0，且一定至少存在一条通路

输入格式

第一行包含两个整数 n 和 m
接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数

数据范围

`1`	`1 ≤ n, m ≤ 100`

输入样例

输出样例

分析

每次在 上下左右 四个方向上移动 1 步，抽象为无权图的最短路径问题

BFS（广度优先搜索） 可以保证 最先到达终点的一定是最短路径

变量定义
- g[N][N] 记录迷宫（0 可通行，1 代表墙）
- d[N][N] 记录 从起点 (0, 0) 到当前点 (i, j) 需要走的步数，初始值设为 -1 代表未访问
- q[N*N] 是 BFS 队列（数组模拟队列），用于存储待访问的坐标点
BFS 过程
- (0, 0) 开始，将 d[0][0] 设为 0 并入队
- 依次处理队列中的每个点 (x, y)：
  - 遍历四个方向 dx[i], dy[i]，尝试移动到 (a, b) = (x + dx[i], y + dy[i])
  - 如果 (a, b) 没超出边界、未访问、且 g[a][b] == 0（可通行），则：
    - 记录 d[a][b] = d[x][y] + 1
    - 将 (a, b) 入队，继续搜索
- 终点 (n - 1, m - 1) 的 d 值即为最短路径

时间复杂度

每个格子最多入队一次，BFS 遍历所有点的时间复杂度为 O(nm)

空间复杂度

主要由 d 数组和队列 q 组成，空间复杂度为 O(nm)

C++代码

#include <cstring>
#include <iostream>

const int N = 110;
int g[N][N];  // 迷宫
int d[N][N];  // 记录最短路径步数

int main()
{
  int n, m;
  std::cin >> n >> m;

  // 读取迷宫
  for (int i = 0; i < n; ++ i)
    for (int j = 0; j < m; ++ j)
      std::cin >> g[i][j];

  std::memset(d, -1, sizeof d);  // -1 表示未访问
  d[0][0] = 0;  // 起点步数设为 0

  using PII = std::pair<int, int>;
  PII q[N * N];  // BFS 队列
  int hh = 0, tt = 0;
  q[0] = {0, 0};  // 起点入队

  // 方向数组：右、下、左、上
  int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

  // BFS 遍历
  while (hh <= tt)
  {
    auto [x, y] = q[hh ++ ];  // 取队头元素

    for (int i = 0; i < 4; ++ i)
    {
      int a = x + dx[i], b = y + dy[i];
      if (a >= 0 && a < n && b >= 0 && b < m && g[a][b] == 0 && d[a][b] == -1)
      {
        q[ ++ tt] = {a, b};  // 加入队列
        d[a][b] = d[x][y] + 1;  // 记录步数
      }
    }
  }

  // 输出终点的最短步数
  std::cout << d[n - 1][m - 1] << '\n';

  return 0;
}

Word Ladder

Fri, 31 Jan 2025 00:00:00 +0000

127. 单词接龙

分析

构建字典集合
- 将 wordList 存入哈希集合 S 中，方便快速判断单词是否存在
BFS 初始化
- 用 queue 队列维护当前单词，初始化队列并记录 beginWord 的距离为 0
- 用哈希表 dist 记录每个单词到 beginWord 的最短路径长度
BFS 遍历
- 每次从队列中取出当前单词 cur，尝试修改它的每一位字符
- 对每个字符位置，从 ‘a’ 到 ‘z’ 枚举替换，形成新单词 temp
  - 如果 temp 在字典中且未被访问过：
    - 更新 dist[temp] = dist[cur] + 1，并将其加入队列
    - 如果 temp 等于 endWord，返回转换次数 dist[temp] + 1
终止条件
- 如果 BFS 遍历结束仍未找到 endWord，返回 0

时间复杂度

总时间复杂度 O(L * 26 * N)，L 是单词长度，26 是字母表大小，N 是字典中单词数量

空间复杂度

空间复杂度为 O(N)

C++代码

class Solution
{
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList)
    {
        // 存储字典单词集合
        std::unordered_set<std::string> S;
        for (std::string word : wordList)
            S.insert(word);

        // 记录单词到起点的最短路径长度
        std::unordered_map<std::string, int> dist;
        dist[beginWord] = 0;

        std::queue<std::string> q;
        q.push(beginWord);

        while (!q.empty())
        {
            std::string cur = q.front();
            q.pop();

            // 枚举每个字符位置进行替换
            for (int i = 0; i < cur.size(); ++i)
            {
                std::string temp = cur;
                for (char j = 'a'; j <= 'z'; ++j)
                {
                    temp[i] = j; // 修改第 i 位字符
                    if (S.count(temp) && !dist.count(temp))
                    {
                        dist[temp] = dist[cur] + 1;
                        if (temp == endWord)
                            return dist[temp] + 1; // 返回结果
                        q.push(temp);
                    }
                }
            }
        }
        return 0; // 无法转换
    }
};

Course Schedule II

Fri, 24 Jan 2025 00:00:00 +0000

210. 课程表II

分析

建图与统计入度
- 使用邻接表表示课程之间的依赖关系
- 使用一个数组记录每门课程的入度（依赖它的课程数）
使用队列进行拓扑排序
- 将入度为 0 的课程加入队列，表示这些课程没有依赖，可以直接学习
- 依次从队列中取出课程，将其加入结果序列，并减少依赖它的课程的入度。如果某课程的入度变为 0，则将其加入队列
判断是否可行
- 如果完成拓扑排序后，结果序列的长度等于课程总数，说明可以完成所有课程；否则说明存在循环依赖，无法完成课程学习

时间复杂度

建图和统计入度需要 O(E)，其中 E 为依赖关系的数量
拓扑排序遍历每个节点及其边，总时间复杂度为 O(V + E)，其中 V 为课程数

空间复杂度

邻接表和入度数组的存储需要 O(V + E)
队列和结果数组的空间为 O(V)

总体复杂度为 O(V + E)

C++代码

class Solution
{
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites)
    {
        // 建图和入度数组
        std::vector<std::vector<int>> g(numCourses);
        std::vector<int> d(numCourses);

        // 构建图并计算入度
        for (std::vector<int>& pre : prerequisites)
        {
            g[pre[1]].push_back(pre[0]);
            ++d[pre[0]];
        }

        // 将入度为 0 的课程加入队列
        std::queue<int> q;
        for (int i = 0; i < numCourses; ++i)
            if (d[i] == 0)
                q.push(i);

        // 拓扑排序
        std::vector<int> res;
        while (!q.empty())
        {
            int i = q.front();
            q.pop();
            res.push_back(i); // 将当前课程加入结果序列

            // 遍历当前课程的后继节点
            for (int j : g[i])
            {
                if (--d[j] == 0) // 如果入度减为 0，则加入队列
                    q.push(j);
            }
        }

        // 如果结果序列的长度等于课程数，则返回结果；否则返回空数组
        return res.size() == numCourses ? res : std::vector<int>();
    }
};

Minimum Genetic Mutation

Fri, 24 Jan 2025 00:00:00 +0000

433. 最小基因变化

分析

数据准备
- 将基因库 bank 存入一个哈希集合 gene 中，方便快速判断某个基因序列是否有效
- 用哈希表 hash 记录每个基因序列的访问状态及其变化次数
初始化 BFS
- 将起始基因序列 startGene 入队，设初始变化次数为 0
BFS 遍历
- 每次从队列中取出当前基因序列 s，对其进行逐位变换。
- 枚举 8 个字符中的每一位，尝试将其替换为 ‘A’、‘C’、‘G’ 或 ‘T’
- 对于每个生成的新基因序列 t，若它在基因库中且未被访问过
  - 将其加入队列，并记录变化次数 hash[t] = hash[s] + 1
  - 若 t == endGene，则直接返回变化次数
结束条件：
- 如果 BFS 遍历完队列仍未找到 endGene，则返回 -1

时间复杂度

每个基因序列有 8 个字符，每个字符有 4 种变换，最多产生 O(8 * 4 * n) 次尝试，其中 n 是基因库的大小
BFS 遍历每个基因序列一次，复杂度为 O(n)

总时间复杂度为 O(32n) ，即 O(n)

空间复杂度

哈希集合 gene 和 hash 占用 O(n) 空间
队列最多存储 O(n) 个基因序列

总空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int minMutation(string startGene, string endGene, vector<string>& bank)
    {
        // 基因库存入哈希集合
        std::unordered_set<std::string> gene;
        for (std::string& b : bank)
            gene.insert(b);

        // BFS 相关数据结构
        std::unordered_map<std::string, int> hash; // 记录访问状态及变化次数
        std::queue<std::string> q;
        hash[startGene] = 0; // 起始基因变化次数为 0
        q.push(startGene);

        char ge_ch[4] = {'A', 'C', 'G', 'T'}; // 可用字符
        while (!q.empty()) {
            std::string s = q.front();
            q.pop();

            // 对当前基因序列逐位尝试变换
            for (int i = 0; i < s.size(); ++i)
            {
                std::string t = s; // 新的基因序列
                for (char c : ge_ch)
                {
                    t[i] = c; // 修改第 i 位
                    // 若新序列有效且未访问过
                    if (gene.count(t) && hash.count(t) == 0)
                    {
                        hash[t] = hash[s] + 1; // 记录变化次数
                        if (t == endGene) // 找到目标序列
                            return hash[t];
                        q.push(t); // 入队继续搜索
                    }
                }
            }
        }
        return -1; // 无法到达目标序列
    }
};

Snakes And Ladders

Fri, 24 Jan 2025 00:00:00 +0000

909. 蛇梯棋

分析

坐标与编号的映射
- 根据题目中的「转行交替方式」编号规则，从左下角开始生成一个 id 数组，表示棋盘位置与编号的对应关系
- 还需要记录每个编号对应的二维坐标 cord，便于查找棋盘上的位置
广度优先搜索（BFS）
- 用队列维护当前可以到达的位置
- 每次模拟掷骰子，从当前编号 k 出发，考虑 [k+1, \min(k+6, n^2)] 范围内的目标编号
- 如果目标编号存在梯子或蛇（即 board[x][y] != -1），直接跳转到指定位置。
终止条件
- 如果当前编号是 n^2，直接返回当前步数
- 若队列为空仍未到达终点，返回 -1，表示无法到达终点

时间复杂度

构建编号与坐标映射需要 O(n^2)
BFS 遍历每个节点，并检查最多 6 条边，复杂度为 O(n^2)

总时间复杂度 O(n^2)

空间复杂度

存储坐标映射和队列所需空间均为 O(n^2)

总空间复杂度为 O(n^2)

C++代码

class Solution
{
public:
    #define x first
    #define y second
    int snakesAndLadders(vector<vector<int>>& board)
    {
        int n = board.size();
        // 记录编号与坐标的映射
        std::vector<std::vector<int>> id(n, std::vector<int>(n));
        using PII = std::pair<int, int>;
        std::vector<PII> cord(n * n + 1);

        // 生成棋盘编号与坐标的映射
        int k = 1, direct = 0;
        for (int i = n - 1; i >= 0; --i)
        {
            if (direct % 2 == 0)
            { // 从左到右
                for (int j = 0; j < n; ++j)
                {
                    id[i][j] = k;
                    cord[k] = {i, j};
                    ++k;
                }
            }
            else
            { // 从右到左
                for (int j = n - 1; j >= 0; --j)
                {
                    id[i][j] = k;
                    cord[k] = {i, j};
                    ++k;
                }
            }
            ++ direct;
        }

        // BFS 寻找最短路径
        std::queue<PII> q;
        std::vector<std::vector<int>> dist(n, std::vector<int>(n, 1e9));
        q.push({n - 1, 0}); // 从起点开始
        dist[n - 1][0] = 0;

        while (!q.empty())
        {
            PII t = q.front();
            q.pop();

            int k = id[t.x][t.y]; // 当前编号
            if (k == n * n) // 到达终点
                return dist[t.x][t.y];

            for (int i = k + 1; i <= k + 6 && i <= n * n; ++i)
            {
                int x = cord[i].x, y = cord[i].y;
                if (board[x][y] == -1)
                { // 无蛇无梯子
                    if (dist[x][y] > dist[t.x][t.y] + 1)
                    {
                        dist[x][y] = dist[t.x][t.y] + 1;
                        q.push({x, y});
                    }
                }
                else
                { // 存在蛇或梯子
                    int ladder = board[x][y];
                    x = cord[ladder].x, y = cord[ladder].y;
                    if (dist[x][y] > dist[t.x][t.y] + 1)
                    {
                        dist[x][y] = dist[t.x][t.y] + 1;
                        q.push({x, y});
                    }
                }
            }
        }
        return -1; // 无法到达终点
    }
};

Populating Next Right Pointers In Each Node

Mon, 20 Jan 2025 00:00:00 +0000

116. 填充每个节点的下一个右侧节点指针

分析

虚拟头节点
- 在每一层，用一个虚拟的头节点 head 来连接下一层的节点。head 节点的 next 指针指向当前层已连接的节点，以便后续填充下一层的 next 指针
遍历当前层的节点
- 对于当前层的每一个节点，我们依次处理它的左右子节点。如果左子节点存在，将其通过 next 指针连接到当前层的 tail 上；然后更新 tail。同样地，处理右子节点
更新指针指向下一层
- 完成当前层的处理后，更新 cur 指向下一层的第一个节点（即虚拟头节点 head 的 next 指针）。然后继续处理下一层，直到所有层都被处理
返回结果
- 最后返回处理后的根节点

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    Node* connect(Node* root)
    {
        Node* cur = root;
        // 当前层存在节点时，继续遍历
        while (cur)
        {
            // 创建一个虚拟头节点，用于连接下一层的节点
            Node* head = new Node(-1);
            Node* tail = head; // tail 用于指向当前层已连接的最后一个节点

            // 遍历当前层的所有节点
            for (Node* p = cur; p; p = p->next)
            {
                // 如果左子节点存在，将其连接到当前层的 tail
                if (p->left)
                    tail = tail->next = p->left;

                // 如果右子节点存在，将其连接到当前层的 tail
                if (p->right)
                    tail = tail->next = p->right;
            }

            // 当前层遍历完成后，更新 cur 指向下一层的第一个节点
            cur = head->next; // head->next 是下一层的第一个节点
        }

        return root; // 返回处理后的根节点
    }
};

Populating Next Right Pointers In Each Node II

Mon, 20 Jan 2025 00:00:00 +0000

117. 填充每个节点的下一个右侧节点指针II

分析

虚拟头节点
- 在每一层，用一个虚拟的头节点 head 来连接下一层的节点。head 节点的 next 指针指向当前层已连接的节点，以便后续填充下一层的 next 指针
遍历当前层的节点
- 对于当前层的每一个节点，我们依次处理它的左右子节点。如果左子节点存在，将其通过 next 指针连接到当前层的 tail 上；然后更新 tail。同样地，处理右子节点
更新指针指向下一层
- 完成当前层的处理后，更新 cur 指向下一层的第一个节点（即虚拟头节点 head 的 next 指针）。然后继续处理下一层，直到所有层都被处理
返回结果
- 最后返回处理后的根节点

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    Node* connect(Node* root)
    {
        Node* cur = root;
        // 当前层存在节点时，继续遍历
        while (cur)
        {
            // 创建一个虚拟头节点，用于连接下一层的节点
            Node* head = new Node(-1);
            Node* tail = head; // tail 用于指向当前层已连接的最后一个节点

            // 遍历当前层的所有节点
            for (Node* p = cur; p; p = p->next)
            {
                // 如果左子节点存在，将其连接到当前层的 tail
                if (p->left)
                    tail = tail->next = p->left;

                // 如果右子节点存在，将其连接到当前层的 tail
                if (p->right)
                    tail = tail->next = p->right;
            }

            // 当前层遍历完成后，更新 cur 指向下一层的第一个节点
            cur = head->next; // head->next 是下一层的第一个节点
        }

        return root; // 返回处理后的根节点
    }
};

Nearest Exit From Entrance In Maze

Fri, 03 Jan 2025 00:00:00 +0000

1926. 迷宫中离入口最近的出口

分析

初始化一个二维数组 dist，用来记录从入口到每个位置的步数，初始值为无穷大 INF
将入口位置的步数置为 0，并将其加入队列。
使用 BFS 依次扩展当前格子，尝试向上下左右 4 个方向移动：
- 如果目标格子在边界上并且是出口，返回步数。
- 如果目标格子可达（空格子，未访问过），更新步数并加入队列
如果队列为空，说明无法找到出口，返回 -1

时间复杂度

BFS 遍历迷宫每个空格子一次，每个格子最多处理 4 个方向

总时间复杂度为 O(n * m)，其中 n 和 m 分别为迷宫的行数和列数

空间复杂度

需要存储距离矩阵 dist 和 BFS 的队列，均为 O(n * m)

总空间复杂度为 O(n * m)

C++代码

class Solution
{
public:
    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance)
    {
      int n = maze.size(), m = maze[0].size();
      int INF = 0x3f3f3f3f; // 表示无穷大
      std::vector<std::vector<int>> dist(n, std::vector<int>(m, INF));
      dist[entrance[0]][entrance[1]] = 0; // 入口步数初始化为 0

      using PII = std::pair<int, int>;
      std::queue<PII> q;
      q.push({entrance[0], entrance[1]});

      // 定义四个移动方向
      int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
      while (q.size())
      {
        PII t = q.front();
        q.pop();
        int x = t.first, y = t.second;
        for (int i = 0; i < 4; ++ i) // 尝试上下左右四个方向
        {
          int a = x + dx[i], b = y + dy[i];
          // 检查新位置是否有效
          if (a >= 0 && a < n && b >= 0 && b < m && maze[a][b] == '.' && dist[a][b] > dist[x][y] + 1)
          {
            dist[a][b] = dist[x][y] + 1; // 更新步数
            // 如果新位置是出口（在边界上）
            if (a == 0 || a == n - 1 || b == 0 || b == m - 1)
              return dist[a][b];
            q.push({a, b}); // 加入队列
          }
        }
      }
      return -1; // 无法找到出口
    }
};

Maximum Level Sum Of A Binary Tree

Wed, 01 Jan 2025 00:00:00 +0000

1161. 最大层内元素和

分析

层序遍历：
- 使用队列实现二叉树的层序遍历，从上到下逐层处理节点
- 每次处理完一层后，将当前层的所有子节点加入队列，供下一层处理
记录每层的总和：
- 对于每层的节点，计算该层所有节点值的总和
- 如果当前层的总和大于之前记录的最大总和，则更新最大总和，并记录当前层号
返回结果：
- 遍历完成后，返回总和最大的最小层号

时间复杂度

每个节点仅被访问一次，因此时间复杂度为 O(n)，其中 n 是二叉树的节点数

空间复杂度

队列中最多存储一层的节点数，在最坏情况下（完全二叉树），空间复杂度为 O(w)，其中 w 是二叉树的最大宽度

C++代码

class Solution
{
public:
    int maxLevelSum(TreeNode* root)
    {
      if (!root)
        return 0;
      std::queue<TreeNode*> q; // 队列用于层序遍历
      q.push(root);            // 将根节点入队
      int res = 0;             // 保存最大总和对应的层号
      int layer = 0;           // 当前层号
      int sum = INT_MIN;       // 初始化最大总和为最小整数

      while (q.size())         // 遍历队列直到为空
      {
        layer ++ ;             // 进入下一层，层号加 1
        int cur = 0;           // 当前层的总和
        int len = q.size();    // 当前层的节点数

        // 遍历当前层的所有节点
        while (len -- )
        {
          TreeNode* t = q.front();
          q.pop();
          if (t->left)         // 将左子节点加入队列
            q.push(t->left);
          if (t->right)        // 将右子节点加入队列
            q.push(t->right);
          cur += t->val;       // 累加当前节点的值
        }

        // 如果当前层的总和大于之前的最大总和，更新
        if (sum < cur)
        {
          sum = cur;           // 更新最大总和
          res = layer;         // 更新最大总和对应的层号
        }
      }

      return res;              // 返回层号
    }
};

Binary Tree Right Side View

Mon, 30 Dec 2024 00:00:00 +0000

199. 二叉树的右视图

分析

层序遍历二叉树：
- 使用队列（queue）进行二叉树的层序遍历
- 每次遍历一层节点时，将当前层的所有节点按顺序加入队列，同时将下一层的子节点也加入队列
记录右视图的节点值：
- 在遍历当前层时，记录当前层的最后一个节点的值，即为该层右侧视图中可见的节点
返回结果：
- 所有层的最后一个节点值构成二叉树的右视图

时间复杂度

时间复杂度：O(n)，其中 n 是二叉树中的节点数

空间复杂度

空间复杂度：O(w)，其中 w 是二叉树的最大宽度

C++代码

class Solution
{
public:
    vector<int> rightSideView(TreeNode* root)
    {
        std::vector<int> res; // 存储右视图节点值
        std::queue<TreeNode*> q; // 队列用于层序遍历

        if (!root) // 如果树为空，返回空结果
            return res;

        q.push(root); // 将根节点加入队列
        while (!q.empty())
        {
            int len = q.size(); // 当前层的节点数量
            while (len--)
            {
                TreeNode* temp = q.front(); // 获取当前层的节点
                q.pop();

                // 如果是当前层的最后一个节点，加入结果集
                if (len == 0)
                    res.push_back(temp->val);

                // 将左子节点加入队列
                if (temp->left)
                    q.push(temp->left);

                // 将右子节点加入队列
                if (temp->right)
                    q.push(temp->right);
            }
        }
        return res; // 返回右视图节点值
    }
};

Rotting Oranges

Tue, 03 Dec 2024 00:00:00 +0000

994. 腐烂的橘子

分析

初始状态
- 遍历整个网格 grid，找到所有腐烂橘子（值为 2），并将其坐标加入队列 q 中
- 初始化时间计数器 res 为 -1，表示腐烂传播的分钟数
广度优先搜索BFS扩散
- 使用 BFS 模拟腐烂橘子的扩散过程，每次遍历队列中的腐烂橘子，将其四周的相邻新鲜橘子（值为 1）腐烂，并将新腐烂的橘子加入队列
- 每完成一次队列的扩散操作，时间计数器 res 加 1
检查剩余新鲜橘子
- 遍历网格，若仍存在新鲜橘子（值为 1），返回 -1
- 否则返回 res，表示所有橘子腐烂所需的最小分钟数

时间复杂度

遍历网格：初始状态下遍历所有单元格 O(n * m)
BFS 扩散：每个橘子最多入队一次，时间复杂度为 O(n * m)

总时间复杂度 O(n * m)

空间复杂度

队列：队列中存储橘子的坐标，最多为 O(m * n)

总空间复杂度：O(m * n)

C++代码

class Solution
{
public:
    int orangesRotting(vector<vector<int>>& grid)
    {
        using PII = std::pair<int, int>;
        std::queue<PII> q;
        int n = grid.size(), m = grid[0].size();

        // 将所有初始腐烂橘子的坐标加入队列
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                if (grid[i][j] == 2)
                    q.push({i, j});

        int res = 0;
        if (!q.empty()) --res; // 队列非空，初始化分钟数为 -1
        int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

        // BFS 扩散腐烂
        while (!q.empty()) {
            ++res; // 每遍历一层队列，时间加 1
            int len = q.size();
            while (len--) {
                PII tmp = q.front();
                q.pop();
                int x = tmp.first, y = tmp.second;

                // 遍历四个方向
                for (int i = 0; i < 4; ++i) {
                    int a = x + dx[i], b = y + dy[i];
                    if (a < 0 || a >= n || b < 0 || b >= m || grid[a][b] != 1)
                        continue;
                    q.push({a, b});     // 加入新腐烂的橘子
                    grid[a][b] = 2;     // 标记为腐烂
                }
            }
        }

        // 检查是否有剩余新鲜橘子
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                if (grid[i][j] == 1)
                    return -1; // 仍有新鲜橘子，返回 -1

        return res; // 返回所需的分钟数
    }
};

Level Order

Mon, 02 Dec 2024 00:00:00 +0000

102. 二叉树的层序遍历

分析

初始化结果数组 res 和队列 q
若 root 为空，直接返回空的 res
将根节点加入队列，进入循环：
- 获取当前层节点数量 len
- 遍历当前层的所有节点：
  - 弹出队头节点，加入当前层结果数组 level
  - 将该节点的左右子节点（若存在）加入队列
- 将当前层的结果 level 加入到 res 中

时间复杂度

时间复杂度 O(n)，其中 n 是二叉树的节点总数。每个节点都会被访问一次

空间复杂度

空间复杂度 O(m)，其中 m 是二叉树的最大宽度。队列在最宽的层存储所有节点

C++代码

class Solution
{
public:
    vector<vector<int>> levelOrder(TreeNode* root)
    {
        // 存储最终结果
        std::vector<std::vector<int>> res;
        if (!root) return res; // 特殊情况：空树

        // 初始化队列
        std::queue<TreeNode*> q;
        q.push(root);

        // 遍历每一层
        while (!q.empty())
        {
            int len = q.size(); // 当前层节点数
            std::vector<int> level; // 存储当前层的节点值

            // 遍历当前层的节点
            while (len--)
            {
                TreeNode* node = q.front();
                q.pop();
                level.push_back(node->val); // 将节点值加入当前层结果
                if (node->left) q.push(node->left); // 加入左子节点
                if (node->right) q.push(node->right); // 加入右子节点
            }
            res.push_back(level); // 将当前层结果加入到最终结果
        }

        return res; // 返回层序遍历结果
    }
};

Maximum Depth of Binary Tree

Sun, 01 Dec 2024 00:00:00 +0000

104. 二叉树的最大深度

分析

初始化
- 创建一个变量 res，初始化为 0，用于记录树的最大深度
- 创建一个队列 q，用于辅助层序遍历
处理根节点
- 如果根节点 root 不为空，将其加入队列
层序遍历
- 每次从队列中取出当前层的所有节点（根据队列长度决定）
- 遍历当前层的节点，依次将每个节点的左右子节点加入队列
- 每处理完一层后，将深度变量 res 增加 1
返回结果
- 当队列为空时，树的所有层已遍历完，返回变量 res，即为最大深度

时间复杂度

每个节点被访问一次，因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

队列的最大空间取决于某一层的最大节点数。在完全二叉树的情况下，最大节点数可能是 n/2，因此空间复杂度为 O(n)

C++代码

// BFS
class Solution
{
public:
    int maxDepth(TreeNode* root)
    {
        int res = 0;  // 初始化深度为 0
        std::queue<TreeNode*> q;  // 辅助队列，用于层序遍历

        if (root)
            q.push(root);  // 如果根节点非空，加入队列

        while (!q.empty())  // 队列非空时，继续遍历
        {
            int len = q.size();  // 当前层的节点数量

            // 遍历当前层的所有节点
            while (len--)
            {
                TreeNode* node = q.front();  // 获取队首节点
                q.pop();  // 弹出队首节点

                // 将当前节点的左右子节点加入队列
                if (node->left)
                    q.push(node->left);
                if (node->right)
                    q.push(node->right);
            }
            ++res;  // 每完成一层，深度加 1
        }

        return res;  // 返回最大深度
    }
};

// DFS
class Solution
{
public:
    int maxDepth(TreeNode* root)
    {
      if (!root) return 0;
      return std::max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};