DFS on Hang Zhang

Partition Array Into Two Equal Product Subsets

Tue, 03 Jun 2025 00:00:00 +0000

3566. 等积子集的划分方案

算法

用两个变量 mul1 和 mul2 分别表示当前两个子集的乘积
从索引 0 开始枚举每个元素，将其放入 mul1 或 mul2
剪枝：如果任何一边的乘积已经超过 target，当前方案结束
若遍历到末尾，判断是否两个乘积都等于 target

复杂度分析

时间复杂度：O(2^n)，每个数都有两种放法，共 2^n 种可能
空间复杂度：O(n)，递归栈深度最多为 n

C++ 代码

class Solution {
public:
  // DFS 枚举当前第 i 个数放到哪个子集（乘积为 mul1 或 mul2）
  bool dfs(std::vector<int>& nums, int i, long long mul1, long long mul2, long long target)
  {
    if (mul1 > target || mul2 > target) {
      return false; // 剪枝：乘积已经超过目标
    }
    if (i == nums.size()) {
      return mul1 == target && mul2 == target; // 判断是否两个子集都达成目标乘积
    }
    // 尝试将当前数 nums[i] 加入 mul1 或 mul2 子集中
    return dfs(nums, i + 1, mul1 * nums[i], mul2, target) ||
           dfs(nums, i + 1, mul1, mul2 * nums[i], target);
  }

  bool checkEqualPartitions(vector<int>& nums, long long target) {
    return dfs(nums, 0, 1, 1, target); // 初始两个子集乘积为 1
  }
};

Python 代码

class Solution:
    def dfs(self, nums: List[int], i: int, mul1: int, mul2: int, target: int) -> bool:
      if mul1 > target or mul2 > target:
        return False
      if i == len(nums):
        return mul1 == target and mul2 == target
      return self.dfs(nums, i + 1, mul1 * nums[i], mul2, target) or self.dfs(nums, i + 1, mul1, mul2 * nums[i], target)

    def checkEqualPartitions(self, nums: List[int], target: int) -> bool:
      return self.dfs(nums, 0, 1, 1, target)

Go 代码

func dfs(nums []int, i int, mul1 int, mul2 int, target int) bool {
  if mul1 > target || mul2 > target {
    return false
  }
  if i == len(nums) {
    return mul1 == target && mul2 == target
  }
  return dfs(nums, i + 1, mul1 * nums[i], mul2, target) || dfs(nums, i + 1, mul1, mul2 * nums[i], target)
}

func checkEqualPartitions(nums []int, target int64) bool {
  return dfs(nums, 0, 1, 1, int(target))
}

Path Sum

Thu, 15 May 2025 00:00:00 +0000

112. 路径总和

分析

从根节点开始，每次将当前节点值 root->val 从 targetSum 中减去
如果当前节点是叶子节点，判断此时 targetSum == root->val 是否成立
否则递归判断左子树和右子树中是否有满足条件的路径

时间复杂度

时间复杂度 O(n)，最坏情况下每个节点都要访问一次

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool hasPathSum(TreeNode* root, int targetSum)
    {
        if (!root) return false;  // 空节点，返回 false

        // 到达叶子节点，检查当前值是否等于剩余的目标和
        if (!root->left && !root->right)
            return targetSum == root->val;

        // 递归左子树
        if (root->left && hasPathSum(root->left, targetSum - root->val))
            return true;

        // 递归右子树
        if (root->right && hasPathSum(root->right, targetSum - root->val))
            return true;

        // 左右子树都不满足条件
        return false;
    }
};

Path Sum II

Thu, 15 May 2025 00:00:00 +0000

113. 路径总和II

分析

当前节点 root->val 加入 path
从 target 中减去当前节点值
如果当前节点是叶子节点，且 target == 0，说明当前路径满足条件，将 path 加入 res
否则递归左子树和右子树
最后进行回溯，将当前节点从 path 中弹出

时间复杂度

时间复杂度 O(n^2)，最坏情况下每个节点都可能被访问，且每条路径都可能需要复制一份保存到结果中

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res;
    std::vector<int> path;

    void dfs(TreeNode* root, int target)
    {
        path.push_back(root->val);     // 添加当前节点到路径
        target -= root->val;           // 更新剩余目标值

        if (!root->left && !root->right)  // 到达叶子节点
        {
            if (target == 0)
                res.push_back(path);      // 满足条件，加入结果
        }
        else
        {
            if (root->left) dfs(root->left, target);   // 递归左子树
            if (root->right) dfs(root->right, target); // 递归右子树
        }

        path.pop_back();   // 回溯，移除当前节点
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum)
    {
        if (root)
            dfs(root, targetSum);  // 从根节点开始DFS
        return res;
    }
};

Arrange Numbers

Mon, 31 Mar 2025 00:00:00 +0000

排列数字

给定一个整数 n，将数字 1 ∼ n 排成一排，将会有很多种排列方法

现在，请你按照字典序将所有的排列方法输出

输入格式 共一行，包含一个整数 n

输出格式 按字典序输出所有排列方案，每个方案占一行

数据范围

`1`	`1 ≤ n ≤ 7`

输入样例：

输出样例：

分析

数组 path[N] 存储当前排列的路径
布尔数组 st[N] 记录数字是否已经被使用，避免重复选择
递归 dfs(n, u)，表示当前正在构造第 u 个位置的数字：
- 如果 u == n，说明已经构造完成，将 path 输出
- 否则，遍历 1 ~ n，依次尝试将每个未使用的数字填入 path[u]：
  - 标记该数字为已使用 (st[num] = true)
  - 递归进入下一层 dfs(n, u + 1)
  - 回溯，撤销选择 st[num] = false 以尝试其他方案

时间复杂度

全排列的数量为 n!，每个排列需要 O(n) 的时间输出，总体时间复杂度 O(n * n!)

空间复杂度

递归深度最多为 O(n)（递归栈）
path 和 st 数组均为 O(n)

总体空间复杂度 O(n)

C++代码

#include <iostream>

const int N = 10;
int path[N];  // 存储当前排列
bool st[N];   // 记录数字是否已使用

void dfs(int n, int u)
{
  if (u == n) // 递归终点：填满 path 数组
  {
    for (int i = 0; i < n; ++ i)
      std::cout << path[i] << ' ';
    std::cout << '\n';
    return;
  }

  for (int num = 1; num <= n; ++ num) // 依次尝试 1~n
    if (!st[num])  // 确保当前数字未使用
    {
      st[num] = true; // 标记为已使用
      path[u] = num;  // 记录当前选择
      dfs(n, u + 1);  // 递归进入下一层
      st[num] = false; // 回溯，撤销选择
    }
}

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

  dfs(n, 0); // 从第 0 位置开始搜索

  return 0;
}

N-Queens

Mon, 31 Mar 2025 00:00:00 +0000

N 皇后问题

n−皇后问题是指将 n 个皇后放在 n × n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上

现在给定整数 n，请你输出所有的满足条件的棋子摆法

分析

N 皇后问题要求在 N × N 的棋盘上放置 N 个皇后，使得：

同一行 不能有多个皇后
同一列 不能有多个皇后
同一对角线（主对角线、反对角线） 不能有多个皇后

数组
- col[i] 记录第 i 列是否有皇后
- dg[u - i + n] 记录主对角线 (row - col 相同) 是否有皇后
- udg[u + i] 记录副对角线 (row + col 相同) 是否有皇后
- f[N][N] 存储棋盘布局，初始时全部填充 '.'，放置皇后时填 'Q'
深度优先搜索（DFS）+ 回溯
- u == n：说明 n 行都已放置皇后，找到一个合法方案，输出棋盘
- 否则，尝试在当前行 u 的每一列 i 放置皇后：
  - 若 (i, u) 不冲突，则放置 'Q'，更新 col、dg、udg，递归 dfs(n, u + 1)
  - 回溯（撤销选择），恢复 '.'，取消 col、dg、udg 标记

时间复杂度

最坏情况下，回溯需要遍历所有排列，时间复杂度为 O(N!)

空间复杂度

O(N²) 存储棋盘 f
递归深度最多 O(N)，因此递归栈空间复杂度为 O(N)

C++代码

#include <iostream>

const int N = 20;
bool col[N], dg[N], udg[N]; // 标记列、主对角线、副对角线
char f[N][N]; // 存储棋盘

void dfs(int n, int u)
{
  if (u == n) // 终止条件：成功放置 N 个皇后
  {
    for (int i = 0; i < n; i ++ )
      puts(f[i]); // 输出棋盘
    puts(""); // 额外空行
    return;
  }

  for (int i = 0; i < n; ++ i) // 尝试在当前行 u 的每一列 i 放置皇后
    if (!col[i] && !dg[u - i + n] && !udg[u + i]) // 剪枝，检查列 & 对角线是否可用
    {
      col[i] = dg[u - i + n] = udg[u + i] = true; // 标记皇后占用位置
      f[u][i] = 'Q'; // 放置皇后
      dfs(n, u + 1); // 递归放置下一行
      f[u][i] = '.'; // 回溯：恢复空棋盘
      col[i] = dg[u - i + n] = udg[u + i] = false; // 取消标记
    }
}

int main()
{
  int n;
  std::cin >> n; // 读取 N

  // 初始化棋盘
  for (int i = 0; i < n; ++ i)
    for (int j = 0; j < n; ++ j)
      f[i][j] = '.';

  dfs(n, 0); // 递归搜索

  return 0;
}

Number of Unique Paths

Thu, 13 Mar 2025 00:00:00 +0000

不同路径数

给定一个 n × m 的二维矩阵，其中的每个元素都是一个 [1,9] 之间的正整数

从矩阵中的任意位置出发，每次可以沿上下左右四个方向前进一步，走过的位置可以重复走

走了 k 次后，经过的元素会构成一个 k + 1 位数。

请求出一共可以走出多少个不同的 k + 1 位数。

输入格式

第一行包含三个整数 n, m, k。

接下来 n 行，每行包含 m 个空格隔开的整数，表示给定矩阵

输出格式

输出一个整数，表示可以走出的不同 k+1 位数的个数

数据范围

对于 30% 的数据, 1 ≤ n, m ≤ 2, 0 ≤ k ≤ 2 对于 100% 的数据，1 ≤ n, m ≤ 5, 0 ≤ k ≤ 5, m × n > 1

输入样例：

输出样例：

分析

遍历起点：矩阵中每个 (i, j) 坐标都可以作为起点，进行搜索
深度优先搜索进行数的构造：
- 递归地沿上下左右 4 个方向移动。
- 走 k 步后，将生成的 k + 1 位数存入 unordered_set，去重后计算数量
- 递归参数包括当前位置 (x, y)、已走步数 u、当前构造的数字 cur
输出不同数的总个数

时间复杂度

每个格子最多 4^k 次递归调用，整体复杂度 O(nm * 4^k)

空间复杂度

空间复杂度为 O(1)

C++代码

#include <iostream>
#include <unordered_set>

const int N = 10;
int g[N][N];  // 存储输入矩阵
std::unordered_set<int> s;  // 记录不同的 k + 1 位数
int n, m, k;

int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};  // 方向数组，表示四个方向的移动

// 深度优先搜索 (DFS)
void dfs(int x, int y, int u, int cur)
{
    if (u == k)  // 走 k 步后，存入 set
        s.insert(cur);
    else
    {
        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)  // 确保不越界
                dfs(a, b, u + 1, cur * 10 + g[a][b]);  // 递归搜索
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);  // 读取 n, m, k
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            scanf("%d", &g[i][j]);  // 读取矩阵数据

    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            dfs(i, j, 0, g[i][j]);  // 每个点作为起点进行 DFS

    printf("%d\n", s.size());  // 输出不同的 k + 1 位数个数
    return 0;
}

Combinations

Sat, 01 Feb 2025 00:00:00 +0000

77. 组合

分析

初始化与递归入口
- 定义 path 存储当前选择的组合，res 存储所有合法结果
- 调用 dfs(n, k, 1) 开始递归。
递归终止条件
- 若选满 k 个数（即 k == 0），将当前路径加入结果 res，并返回
递归过程
- 遍历从 start 到 n 的所有数：
  - 将当前数加入 path
  - 递归调用 dfs(n, k - 1, i + 1) 进入下一层搜索
  - 回溯时弹出当前数字，恢复状态

时间复杂度

总时间复杂度 O(C_n^k)，组合数量为 C_n^k = n! / k!(n-k)!，每个组合需要遍历一次

空间复杂度

空间复杂度为 O(k)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res;  // 存储结果
    std::vector<int> path;              // 当前路径

    vector<vector<int>> combine(int n, int k)
    {
        dfs(n, k, 1);  // 从数字 1 开始递归
        return res;
    }

    void dfs(int n, int k, int start)
    {
        // 递归终止条件：已选择 k 个数
        if (!k)
        {
            res.push_back(path);
            return;
        }

        for (int i = start; i <= n; ++i)
        {
            path.push_back(i);          // 选择当前数
            dfs(n, k - 1, i + 1);       // 递归搜索下一层
            path.pop_back();            // 回溯，撤销选择
        }
    }
};

Design Add and Search Words Data Structure

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

211. 添加与搜索单词

分析

构建 Trie 树
- Node 节点中包含：
  - 一个 son[26] 数组，用于存储 26 个字母子节点指针
  - 一个 ended 布尔变量，标记当前节点是否为某单词的结尾
- addWord() 操作：
  - 从根节点出发，逐字符插入 Trie 中，不存在的节点创建新的子节点
  - 插入完成后将末尾节点标记为单词结束
实现查找逻辑
- search() 方法调用 dfs() 深搜判断是否能匹配给定单词
DFS 搜索策略
- 遇到普通字符：检查对应子节点是否存在，递归查找下一字符
- 遇到 .：遍历所有子节点，若任一分支匹配成功即可返回 true
- 若遍历结束时抵达有效单词结尾，则返回 true

时间复杂度

addWord(word)：O(L)，其中 L 是单词长度
search(word)：
- 普通查找：O(L)
- 含 . 的查找：最坏情况 O(26^L)

空间复杂度

O(N \times L)，N 为单词数量，L 为单词平均长度

C++代码

class WordDictionary
{
public:
    struct Node {
        Node() {
            ended = false;
            for (int i = 0; i < 26; ++i)
                son[i] = nullptr;
        }
        Node* son[26];  // 子节点数组
        bool ended;     // 标记单词结束
    };

    Node* root;

    WordDictionary() {
        root = new Node();
    }

    // 插入单词
    void addWord(string word) {
        Node* p = root;
        for (char c : word) {
            int u = c - 'a';
            if (!p->son[u])
                p->son[u] = new Node();
            p = p->son[u];
        }
        p->ended = true;
    }

    // 查找单词
    bool search(string word) {
        return dfs(root, word, 0);
    }

    // 深度优先搜索实现查找逻辑
    bool dfs(Node* p, std::string word, int i) {
        if (i == word.size())
            return p->ended;  // 抵达单词末尾，判断是否有效
        if (word[i] != '.') {
            int u = word[i] - 'a';
            if (p->son[u])
                return dfs(p->son[u], word, i + 1);
        } else {
            for (int j = 0; j < 26; ++j) {
                if (p->son[j] && dfs(p->son[j], word, i + 1))
                    return true;
            }
        }
        return false;
    }
};

Minimum Absolute Difference In BST

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

530. 二叉搜索树的最小绝对差

分析

中序遍历：
- 按左子树 → 根节点 → 右子树的顺序遍历树，使得节点值按从小到大的顺序访问
计算最小差值：
- 在遍历过程中，记录上一个节点值 last
- 对当前节点值 root->val 和 last 计算差值，并更新最小差值 res
初始化：
- 使用一个布尔变量 firsted 标记是否是第一次访问节点，用于跳过第一个节点的差值计算
返回结果：
- 中序遍历完成后，res 即为任意两节点值之间的最小差值

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(logn)

C++代码

class Solution
{
public:
    int res = INT_MAX; // 最小差值的初始化
    int last;          // 上一个访问的节点值
    bool firsted = true; // 是否是第一个访问的节点

    int getMinimumDifference(TreeNode* root)
    {
        dfs(root); // 中序遍历
        return res;
    }

    void dfs(TreeNode* root)
    {
        if (!root)
            return;

        // 遍历左子树
        dfs(root->left);

        // 访问当前节点
        if (firsted)
            firsted = false; // 标记第一个节点
        else
            res = std::min(res, root->val - last); // 更新最小差值
        last = root->val; // 更新上一个节点值

        // 遍历右子树
        dfs(root->right);
    }
};

Surrounded Regions

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

130. 被围绕的区域

分析

标记无法被包围的区域：
- 从矩阵的边界出发，对边界的 ‘O’ 及其连通区域用 ‘*’ 标记，表示这些 ‘O’ 无法被包围。
填充被围绕的区域：
- 遍历矩阵，将未被标记的 ‘O’ 替换为 ‘X’，表示这些区域已被包围。
还原未被包围的区域：
- 将标记为 ‘*’ 的位置还原为 ‘O’。

时间复杂度

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

空间复杂度

DFS 的递归调用栈深度与矩阵中最长的连通区域有关，空间复杂度为 O(n * m)

C++代码

class Solution
{
public:
    int n = 0, m = 0; // 矩阵的行数和列数
    int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; // 四个方向：右、下、左、上

    void solve(vector<vector<char>>& board)
    {
        n = board.size(), m = board[0].size();
        if (n == 0 || m == 0)
            return;

        // 从边界出发，标记无法被包围的区域
        for (int i = 0; i < n; ++i)
        {
            if (board[i][0] == 'O')
                dfs(board, i, 0); // 左边界
            if (board[i][m - 1] == 'O')
                dfs(board, i, m - 1); // 右边界
        }
        for (int i = 0; i < m; ++i)
        {
            if (board[0][i] == 'O')
                dfs(board, 0, i); // 上边界
            if (board[n - 1][i] == 'O')
                dfs(board, n - 1, i); // 下边界
        }

        // 遍历矩阵，处理未被标记的区域
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                if (board[i][j] == '*')
                    board[i][j] = 'O'; // 还原被标记的区域
                else
                    board[i][j] = 'X'; // 填充被包围的区域
            }
        }
    }

    void dfs(std::vector<std::vector<char>>& board, int x, int y)
    {
        board[x][y] = '*'; // 标记当前区域
        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 && board[a][b] == 'O')
                dfs(board, a, b); // 递归标记连通区域
        }
    }
};

Count Complete Tree Nodes

Tue, 21 Jan 2025 00:00:00 +0000

222. 完全二叉树的节点个数

分析

递归终止条件：如果当前节点为空，则返回 0，表示没有节点
递归步骤：对当前节点，递归计算其左子树和右子树的节点个数，然后返回左右子树节点数的和加上当前节点本身

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(logn)

C++代码

class Solution
{
public:
    int countNodes(TreeNode* root)
    {
      // 如果树为空，节点个数为 0
      if (!root)
        return 0;

      // 递归计算左子树和右子树的节点个数，并加上当前节点
      return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

Same Tree

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

100. 相同的树

分析

递归判断根节点：首先检查两个根节点 p 和 q 的值是否相等，如果它们相等，就继续递归地检查它们的左右子树
递归判断左右子树：分别递归比较 p 的左子树与 q 的左子树，p 的右子树与 q 的右子树
递归的终止条件：
- 如果两个节点都为空，说明它们相等
- 如果两个节点其中一个为空，或者它们的值不相等，返回 false
最终结果：只有当根节点和左右子树都完全相同的情况下，两棵树才是相同的

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)，h 是树的高度

C++代码

class Solution
{
public:
    bool isSameTree(TreeNode* p, TreeNode* q)
    {
        // 如果 p 和 q 都为空，说明它们是相同的
        if (!p && !q)
            return true;

        // 如果 p 和 q 其中一个为空，或它们的值不同，返回 false
        if (!p || !q || p->val != q->val)
            return false;

        // 递归地比较左右子树
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

Reorder Routes To Make All Paths Lead to The City Zero

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

1466. 重新规划路线

分析

建图：
- 将每条路线转化为一个无向图，并为每条边添加方向信息：
  - 如果路线从城市 a -> b，则图中添加边 (a, b, true)（表示这条边需要变更方向）
    - 同时添加反向边 (b, a, false)（表示这条边方向正确，无需变更）
深度优先搜索（DFS）：
- 从城市 0 开始遍历整个图，记录需要变更方向的边数：
  - 如果当前边方向不正确（change == true），则需要修改方向，计数器 res 加 1
- 继续递归访问相邻的未访问城市，确保整个图的连通性
返回结果：
- 最终 res 的值即为需要变更方向的最小路线数

时间复杂度

图中包含 n - 1 条边，DFS 遍历每条边一次，时间复杂度为 O(n)

空间复杂度

存储图的邻接表需要 O(n) 的空间
访问标记数组 visited 和递归栈的空间复杂度为 O(n)

总空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int res = 0;  // 记录需要变更方向的路线数

    // 深度优先搜索函数
    void dfs(int city, std::vector<std::vector<std::pair<int, bool>>>& graph, std::vector<bool>& visited)
    {
        visited[city] = true;  // 标记当前城市为已访问
        for (auto t : graph[city])
        {  // 遍历所有相邻城市
            int neighbor = t.first;
            bool change = t.second;
            if (!visited[neighbor])
            {  // 如果相邻城市未访问
                if (change == true)  // 如果需要改变方向
                    ++res;
                dfs(neighbor, graph, visited);  // 递归访问相邻城市
            }
        }
    }

    // 主函数
    int minReorder(int n, vector<vector<int>>& connections)
    {
        // 构建图
        std::vector<std::vector<std::pair<int, bool>>> graph(n);
        for (auto conn : connections)
        {
            graph[conn[0]].push_back({conn[1], true});  // 原方向
            graph[conn[1]].push_back({conn[0], false}); // 反方向
        }

        // 初始化访问标记数组
        std::vector<bool> visited(n, false);

        // 从城市 0 开始深度优先搜索
        dfs(0, graph, visited);

        return res;  // 返回需要变更方向的最小数目
    }
};

Keys And Rooms

Thu, 02 Jan 2025 00:00:00 +0000

841. 钥匙和房间

分析

转化为图的遍历问题：
- 将每个房间看作一个节点，钥匙之间的关系看作图的边
- 我们需要从节点 0 开始，遍历整个图，检查是否能够访问所有的节点
深度优先搜索（DFS）：
- 使用递归的方式遍历图，从起点 0 开始访问
- 每访问一个节点（房间），将其标记为已访问
- 对于当前房间中的钥匙（指向其他房间的边），检查对应的房间是否已访问，未访问则递归继续
检查结果：
- 遍历完成后，检查是否所有房间都被访问过。如果有任何房间未被访问，则返回 false；否则返回 true

时间复杂度

每个房间和每把钥匙都会被访问一次，因此时间复杂度为 O(n + m)，其中 n 是房间的数量，m 是所有钥匙的总数量

空间复杂度

图的存储需要 O(n + m) 的空间
访问标记数组占用 O(n) 的空间
递归栈的最大深度为 O(n)

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

C++代码

class Solution
{
public:
    void dfs(int room, std::vector<std::vector<int>>& rooms, std::vector<bool>& visited)
    {
      visited[room] = true;        // 标记房间 room 已访问
      for (int x : rooms[room])    // 遍历房间 room 中的钥匙
        if (!visited[x])           // 如果钥匙指向的房间尚未访问
          dfs(x, rooms, visited);  // 递归访问该房间
    }

    bool canVisitAllRooms(vector<vector<int>>& rooms)
    {
      int n = rooms.size();                 // 房间数量
      std::vector<bool> visited(n, false);  // 初始化访问标记数组
      dfs(0, rooms, visited);               // 从房间 0 开始进行深度优先搜索

      // 检查是否所有房间都被访问
      for (int i = 0; i < n; ++ i)
        if (!visited[i])  // 如果有房间未访问，返回 false
          return false;

      return true;  // 所有房间都被访问，返回 true
    }
};

Number Of Provinces

Thu, 02 Jan 2025 00:00:00 +0000

547. 省份数量

分析

图的模型：
- 每个城市看作图中的一个节点。
- isConnected[i][j] = 1 表示城市 i 和 j 之间存在一条边
深度优先搜索（DFS）：
- 使用一个布尔数组 visited 来记录每个城市是否已访问
- 从某个未访问的城市出发，遍历与其直接或间接相连的所有城市，并标记为已访问
- 每次启动新的 DFS，意味着发现了一个新的省份
计数省份：
- 遍历所有城市，当发现一个未访问的城市时，启动一次 DFS，同时将省份数量加 1

时间复杂度

每个城市和每条边都会被访问一次，因此时间复杂度为 O(n^2)，其中 n 是城市数量

空间复杂度

访问标记数组需要 O(n) 的空间
递归栈的深度最多为 O(n)

总空间复杂度为 O(n)

C++代码

class Solution
{
public:
    // 深度优先搜索函数
    void dfs(int city, std::vector<std::vector<int>>& isConnected, std::vector<bool>& visited)
    {
        visited[city] = true;  // 标记当前城市为已访问
        for (int neighbor = 0; neighbor < isConnected.size(); ++neighbor)
            if (isConnected[city][neighbor] == 1 && !visited[neighbor])
                dfs(neighbor, isConnected, visited);  // 递归访问相邻城市
    }

    // 主函数
    int findCircleNum(vector<vector<int>>& isConnected)
    {
        int n = isConnected.size();  // 城市数量
        std::vector<bool> visited(n, false);  // 初始化访问标记数组
        int provinces = 0;  // 省份计数

        // 遍历每个城市
        for (int i = 0; i < n; ++i)
            if (!visited[i]) // 如果城市未被访问
            {
                ++provinces;  // 新发现一个省份
                dfs(i, isConnected, visited);  // 启动深度优先搜索
            }

        return provinces;  // 返回省份数量
    }
};

Longest Zigzag Path In a Binary Tree

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

1372. 二叉树中的最长交错路径

分析

路径的定义：
- 选择一个起始节点和方向：
  - 如果前进方向是右，则移动到右子节点
  - 如果前进方向是左，则移动到左子节点
- 每次移动后，改变方向继续前进
递归处理：
- 使用深度优先搜索（DFS）遍历整棵树
- 每次递归返回以：当前节点为起点的最长交错路径长度
方向参数：
- 每次递归调用带上方向参数 direction：
  - 0 表示上一次路径方向为左
  - 1 表示上一次路径方向为右
路径长度计算：
- 若当前节点移动方向为左，则当前路径长度为右子树返回值 + 1
- 若当前节点移动方向为右，则当前路径长度为左子树返回值 + 1
- 更新全局最大值 res

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    int res = 0; // 全局变量记录最大交错路径长度

    int longestZigZag(TreeNode* root)
    {
        dfs(root, 0); // 从根节点开始递归，初始方向为左
        return res;
    }

    int dfs(TreeNode* root, int direction)
    {
        if (!root) // 空节点返回 0
            return 0;

        // 递归计算左右子树的交错路径
        int left = dfs(root->left, 0);  // 进入左子树，方向为左
        int right = dfs(root->right, 1); // 进入右子树，方向为右

        // 更新最长交错路径
        res = std::max(res, std::max(left, right));

        // 返回以当前节点为起点的路径长度
        if (direction == 0) // 当前方向为左
            return right + 1;
        return left + 1; // 当前方向为右
    }
};

Flatten Binary Tree to Linked List

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

114. 二叉树展开为链表

分析

遍历二叉树的每个节点
如果当前节点存在左子树：
- 将左子树的最右节点找到，并连接到当前节点的右子树上
- 然后将当前节点的右子树替换为它的左子树，同时将左子树置为 null
移动到当前节点的右子节点，继续上述操作，直至遍历完所有节点

时间复杂度

时间复杂度 O(n)，每个节点遍历一次，且寻找左子树最右节点的过程也是线性的

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    void flatten(TreeNode* root)
    {
        while (root) // 遍历每个节点
        {
            TreeNode* p = root->left; // 获取当前节点的左子树
            if (p) // 如果存在左子树
            {
                // 找到左子树的最右节点
                while (p->right)
                    p = p->right;

                // 将左子树的最右节点与右子树连接
                p->right = root->right;

                // 将当前节点的右子树替换为左子树
                root->right = root->left;

                // 将左子树置为 null
                root->left = nullptr;
            }
            // 移动到右子节点
            root = root->right;
        }
    }
};

Kth Smallest Element In A Bst

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

230. 二叉搜索树中第K小元素

分析

使用栈实现中序遍历
- 中序遍历按照「左 -> 根 -> 右」的顺序访问节点，因此可以使用显式栈来模拟递归
- 通过遍历左子树进入更小的节点，将节点依次压栈，直到左子树遍历完成
计数找到第 k 小的元素
- 每次弹出栈顶节点时，计数器 k 减一，直到 k = 0 时，当前节点即为第 k 小的节点
右子树遍历
- 在访问根节点后，转向右子树继续重复上述过程

时间复杂度

时间复杂度 O(h + k)，其中 h 是树的高度，k 是目标元素的位置。我们最多遍历 k 个节点，同时需要沿着树的高度走到叶节点

空间复杂度

空间复杂度：O(h)，栈的最大深度为树的高度

C++代码

class Solution
{
public:
    int kthSmallest(TreeNode* root, int k)
    {
        std::stack<TreeNode*> stk; // 显式栈用于模拟递归
        while (root || !stk.empty())
        {
            // 遍历左子树，将节点压栈
            while (root)
            {
                stk.push(root);
                root = root->left;
            }

            // 处理当前节点
            root = stk.top(); // 获取栈顶元素
            stk.pop();
            if (--k == 0) // 如果 k 减到 0，说明找到第 k 小的节点
                return root->val;

            // 转向右子树
            root = root->right;
        }

        return 0; // 理论上不会执行到这里，保证函数返回值
    }
};

Lowest Common Ancestor Of A Binary Tree

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

236. 二叉树的最近公共祖先

分析

使用递归深度优先搜索（DFS）
- 状态定义：
  - 如果某个子树中找到了 p ，则返回状态 1
  - 如果找到了 q ，则返回状态 2
  - 如果同时找到 p 和 q，状态为 3
- 递归逻辑：
  - 对当前节点的左右子树分别进行递归
  - 将左右子树的状态结果与当前节点的状态进行合并（按位或操作）
  - 如果当前节点的状态等于 3 且最近公共祖先 res 尚未被赋值，则更新 res
终止条件
- 当 p 和 q 在同一个子树中时，递归会找到它们最近的公共祖先并停止
- 如果两个节点在不同子树中，递归逻辑会找到分叉点，即最近公共祖先

时间复杂度

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

空间复杂度

空间复杂度为 O(h)，其中 h 是二叉树的高度，递归调用栈的深度

C++代码

class Solution
{
public:
    TreeNode* res = nullptr; // 存储最近公共祖先节点

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        dfs(root, p, q); // 执行深度优先搜索
        return res; // 返回最近公共祖先
    }

    int dfs(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        int state = 0; // 当前节点的状态
        if (!root)
            return state; // 如果当前节点为空，返回状态 0
        if (root == p)
            state |= 1; // 如果找到节点 p，更新状态为 1
        else if (root == q)
            state |= 2; // 如果找到节点 q，更新状态为 2

        // 递归左右子树
        state |= dfs(root->left, p, q);
        state |= dfs(root->right, p, q);

        // 如果当前状态为 3（即同时找到 p 和 q），且 res 尚未更新，更新 res
        if (state == 3 && !res)
            res = root;

        return state; // 返回当前节点的状态
    }
};

Binary Tree Maximum Path Sum

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

124. 二叉树中的最大路径和

分析

递归定义：
- 对于每个节点，我们通过递归计算以该节点为根的路径的最大贡献值（即该节点能为父节点提供的最大路径和）
贡献值的计算：
- 对于当前节点 root ：
  - 左子树提供的最大路径和 left = max(0, dfs(root->left))。取 0 是为了避免负贡献
  - 右子树提供的最大路径和 right = max(0, dfs(root->right))
更新全局最大路径和：
- 对于当前节点，路径和可能包含其左右子树的贡献值，因此计算路径和为：left + root->val + right
- 更新全局变量 res：res = max(res, left + root->val + right)
返回贡献值：
- 当前节点对父节点的最大贡献值为：root->val + max(left, right)，只取左右子树中的一个路径，避免形成环

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    int res = INT_MIN; // 全局变量，用于记录最大路径和

    int maxPathSum(TreeNode* root)
    {
        dfs(root); // 调用递归函数
        return res; // 返回最终结果
    }

    int dfs(TreeNode* root)
    {
        if (!root) // 如果当前节点为空，返回0
            return 0;

        // 递归计算左、右子树的最大贡献值，负值取0
        int left = std::max(0, dfs(root->left));
        int right = std::max(0, dfs(root->right));

        // 更新全局最大路径和
        res = std::max(res, left + root->val + right);

        // 返回当前节点对父节点的最大贡献值
        return root->val + std::max(left, right);
    }
};

Count Good Nodes In Binary Tree

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

1448. 统计二叉树中好节点

分析

递归遍历：
- 使用深度优先搜索 (DFS) 遍历树中所有节点
- 在遍历过程中，记录从根节点到当前节点路径上的最大值 max_val
判断当前节点是否为好节点：
- 如果当前节点的值大于或等于 max_val，说明该节点是好节点，计数器加一，并更新路径上的最大值为当前节点的值
继续递归左右子树：
- 对当前节点的左右子树递归调用，传递更新后的 max_val
累加结果：
- 将左子树和右子树的好节点数量加上当前节点的结果，返回总计数

时间复杂度

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

空间复杂度

递归调用栈的空间复杂度为 O(h)，其中 h 是树的高度。在最坏情况下（单链树），空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int goodNodes(TreeNode* root)
    {
        // 从根节点开始深度优先搜索，初始路径的最大值为最小整数
        return dfs(root, INT_MIN);
    }

    int dfs(TreeNode* root, int max_val)
    {
        // 如果节点为空，返回0（没有好节点）
        if (!root)
            return 0;

        int res = 0;

        // 判断当前节点是否为好节点
        if (root->val >= max_val)
        {
            res = 1; // 当前节点是好节点
            max_val = root->val; // 更新路径上的最大值
        }

        // 递归左右子树并累加好节点数量
        return res + dfs(root->left, max_val) + dfs(root->right, max_val);
    }
};

Path Sum III

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

437. 路径总和III

分析

使用前缀和优化路径求和
- 前缀和定义：到当前节点的路径和（包括当前节点）
- 公式：假设当前路径的前缀和为 cur，目标和为 targetSum，那么我们需要寻找路径的前缀和 cur - targetSum
  - 若前缀和 cur - targetSum 存在，说明存在一条路径满足路径和等于 targetSum
具体步骤
- 使用哈希表 count 存储前缀和及其出现的次数：
  - count[0] = 1 初始化，表示路径和为 0 的路径有 1 条（即从根节点开始时）
- 深度优先搜索（DFS）遍历树的每个节点，维护当前路径的前缀和：
  - 更新当前节点的前缀和 cur
  - 检查是否存在路径满足 cur - targetSum
  - 将当前路径的前缀和存入哈希表
  - 递归遍历左右子树
  - 回溯时，删除当前节点对前缀和的贡献（将 count[cur]--）

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    std::unordered_map<long, int> count; // 哈希表存储前缀和及其出现次数
    int res = 0; // 记录满足条件的路径数

    int pathSum(TreeNode* root, int targetSum) {
        count[0] = 1; // 初始化路径和为 0 的路径有 1 条
        dfs(root, targetSum, 0); // 开始 DFS 遍历
        return res; // 返回结果
    }

    void dfs(TreeNode* root, int targetSum, long cur) {
        if (!root) return; // 如果当前节点为空，直接返回

        cur += root->val; // 更新当前路径和
        res += count[cur - targetSum]; // 检查是否存在前缀和满足条件
        count[cur]++; // 更新哈希表，记录当前路径和

        dfs(root->left, targetSum, cur); // 遍历左子树
        dfs(root->right, targetSum, cur); // 遍历右子树

        count[cur]--; // 回溯时移除当前节点对前缀和的贡献
    }
};

Leaf Similar Trees

Sat, 28 Dec 2024 00:00:00 +0000

872. 叶子相似的树

分析

深度优先搜索 (DFS)：
- 使用递归遍历二叉树
- 如果当前节点是叶子节点（没有左子节点和右子节点），将其值加入到结果序列中
- 如果不是叶子节点，则递归遍历其左子树和右子树
提取叶值序列：
- 对 root1 和 root2 分别进行深度优先搜索，提取两个叶值序列
比较序列：
- 判断两个序列是否相等，如果相等则返回 true，否则返回 false

时间复杂度

深度优先搜索：
- 对每棵树的所有节点遍历一次，时间复杂度为 O(n) ，其中 n 是节点数量
比较序列：
- 比较两个序列，时间复杂度为 O(min(n, m)) ，其中 n 和 m 分别为两棵树叶子节点的数量

总体时间复杂度为 O(n)

空间复杂度

递归调用栈：
- 在最坏情况下（树的深度为树的高度），递归调用栈需要 O(h) 的空间，其中 h 是树的高度
存储叶值序列：
- 每棵树的叶子节点最多为树节点总数的一半，存储序列的空间复杂度为 O(n)

总体空间复杂度为 O(n)

C++代码

class Solution
{
public:
    // 深度优先搜索，提取叶子节点的值
    void dfs(TreeNode* root, std::vector<int>& res)
    {
        // 如果当前节点为空，直接返回
        if (!root)
            return;

        // 如果当前节点是叶子节点，记录其值
        if (!root->left && !root->right)
            res.push_back(root->val);

        // 递归遍历左子树和右子树
        dfs(root->left, res);
        dfs(root->right, res);
    }

    bool leafSimilar(TreeNode* root1, TreeNode* root2)
    {
        // 分别存储两棵树的叶值序列
        std::vector<int> a, b;

        // 获取第一棵树的叶值序列
        dfs(root1, a);

        // 获取第二棵树的叶值序列
        dfs(root2, b);

        // 比较两棵树的叶值序列
        return a == b;
    }
};

Number of Islands

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

200. 岛屿数量

分析

岛屿的定义
- '1' 表示陆地，'0' 表示水
- 一个岛屿是由相邻（水平或垂直方向）的 '1' 连续组成的一块区域
遍历网格
- 遍历网格中每个位置 (i, j)，若当前位置为 '1'，说明发现了一个新的岛屿：
- 执行深度优先搜索 dfs() 标记当前岛屿的所有陆地为 '*'，表示已访问
- 岛屿数量加 1
深度优先搜索dfs()
- 从当前陆地 (x, y) 出发，尝试向四个方向移动（上、下、左、右）
- 若移动后的位置仍为 '1' 且未越界，递归调用 dfs() 继续标记

时间复杂度

每个格子最多被访问一次，时间复杂度为 O(m * n)，其中 m 和 n 分别是网格的行数和列数

空间复杂度

递归栈深度取决于岛屿的最大面积，最坏情况下为 O(m * n)，即岛屿覆盖整个网格

C++代码

class Solution
{
public:
    std::vector<std::vector<char>> g; // 全局保存网格
    int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; // 四个方向

    int numIslands(vector<vector<char>>& grid)
    {
        g = grid; // 初始化网格
        int res = 0; // 岛屿数量
        for (int i = 0; i < g.size(); ++i)
            for (int j = 0; j < g[0].size(); ++j)
                if (g[i][j] == '1') // 找到未访问的陆地
                {
                    dfs(i, j); // 标记整个岛屿
                    ++res; // 岛屿数量加 1
                }
        return res;
    }

    void dfs(int x, int y)
    {
        g[x][y] = '*'; // 标记当前位置为已访问
        for (int i = 0; i < 4; ++i) // 尝试向四个方向移动
        {
            int a = x + dx[i], b = y + dy[i];
            if (a >= 0 && a < g.size() && b >= 0 && b < g[0].size() && g[a][b] == '1')
                dfs(a, b); // 若新位置是未访问的陆地，递归处理
        }
    }
};

Validate Binary Search Tree

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

98. 验证二叉搜索树

分析

二叉搜索树的性质
- 对于任意节点，其左子树所有节点值均小于该节点值，右子树所有节点值均大于该节点值
递归验证子树
- 每次检查当前节点是否满足范围条件 [l, r]
  - 如果当前节点值小于等于 l 或大于等于 r，直接返回 false
- 对左子树递归验证，更新上界为当前节点值
- 对右子树递归验证，更新下界为当前节点值
递归终止条件
- 当节点为 nullptr 时，返回 true，表示空子树有效

时间复杂度

每个节点只访问一次，时间复杂度为 O(n)，其中 n 为节点数

空间复杂度

递归深度由树的高度决定，空间复杂度为 O(h)，其中 h 为树的高度

最坏情况：链式结构，O(n)
最好情况：平衡二叉树，O(logn)

C++代码

class Solution
{
public:
    bool isValidBST(TreeNode* root)
    {
        // 初始范围设为 LONG_MIN 到 LONG_MAX
        return dfs(root, LONG_MIN, LONG_MAX);
    }

    bool dfs(TreeNode* root, long l, long r)
    {
        if (!root) return true; // 空节点为有效子树
        // 检查当前节点值是否在合法范围内
        if (l >= root->val || r <= root->val)
            return false;
        // 递归检查左子树和右子树
        return dfs(root->left, l, root->val) && dfs(root->right, root->val, r);
    }
};

Invert Binary Tree

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

226. 翻转二叉树

分析

递归结束条件
- 如果当前节点 root 为 nullptr，直接返回 nullptr，表示已到达叶子节点的空子树
交换左右子树
- 使用 std::swap 交换当前节点的左子树和右子树
递归处理子树
- 对交换后的左子树调用 invertTree
- 对交换后的右子树调用 invertTree
返回结果
- 当所有节点都完成翻转后，返回根节点 root

时间复杂度

每个节点被访问一次，执行左右子树的交换操作，因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

递归调用的栈深度取决于树的高度。在最坏情况下（单链表形式的树），空间复杂度为 O(n)；在最优情况下（完全平衡二叉树），空间复杂度为 O(logn)

C++代码

// DFS
class Solution {
public:
    TreeNode* invertTree(TreeNode* root)
    {
        if (!root)
            return nullptr;  // 若节点为空，直接返回
        std::swap(root->left, root->right);  // 交换左右子树
        invertTree(root->left);  // 递归处理左子树
        invertTree(root->right);  // 递归处理右子树
        return root;  // 返回翻转后的树根节点
    }
};

// BFS
class Solution {
public:
    TreeNode* invertTree(TreeNode* root)
    {
        if (!root) return nullptr;

        std::queue<TreeNode*> q;
        q.push(root);  // 将根节点入队

        while (!q.empty()) {
            TreeNode* node = q.front();
            q.pop();

            // 交换左右子树
            std::swap(node->left, node->right);

            // 将子节点入队
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }

        return root;
    }
};

Binary Tree inorder Traversal

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

94. 二叉树的中序遍历

分析

中序遍历的顺序是：左子树 -> 根节点 -> 右子树

初始化数据结构
- 创建一个结果数组 res，用于存储中序遍历的结果
- 创建一个栈 stk，用于辅助遍历
模拟递归过程
- 向左下方向遍历：当前节点非空时，将当前节点压入栈，并将其移动到左子节点
- 回溯节点并访问右子树：如果当前节点为空（即到达左子树的最深处），从栈中弹出一个节点，访问该节点的值并存入结果数组，然后将当前节点移动到其右子节点
- 重复以上过程，直到栈为空且当前节点为空

时间复杂度

每个节点被访问两次（一次压入栈，一次弹出栈），因此时间复杂度为 O(n)，其中 n 是节点总数

空间复杂度

栈的深度取决于树的高度。在最坏情况下（如链状树），栈的空间复杂度为 O(n)；在平衡树中，栈的空间复杂度为 O(logn)

C++代码

// 非递归
class Solution
{
public:
    vector<int> inorderTraversal(TreeNode* root)
    {
        std::vector<int> res;          // 存储中序遍历结果
        std::stack<TreeNode*> stk;     // 辅助栈

        while (root || !stk.empty())   // 当节点非空或栈非空时，继续遍历
        {
            // 一直向左走，将路径上的节点压入栈
            while (root)
            {
                stk.push(root);        // 压入栈
                root = root->left;     // 移动到左子节点
            }

            // 回溯：弹出栈顶节点
            root = stk.top();
            stk.pop();

            res.push_back(root->val);  // 访问节点值

            root = root->right;        // 转向右子树
        }

        return res;                    // 返回结果
    }
};


// 递归
class Solution {
public:
    std::vector<int> res;

    void dfs(TreeNode* root)
    {
      if (!root) return;
      dfs(root->left);
      res.push_back(root->val);
      dfs(root->right);
    }

    vector<int> inorderTraversal(TreeNode* root)
    {
      dfs(root);
      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;
    }
};

Generate Parentheses

Sun, 24 Mar 2024 00:00:00 +0000

22. Generate Parentheses

分析

合法的括号组合需要满足：

左括号 ( 的数量不能超过 n
右括号 ) 的数量不能超过左括号的数量

递归函数在每一步根据当前左括号和右括号的数量，选择是否添加 ( 或 )

如果左括号数量小于 n，可以添加 (
如果右括号数量小于左括号，可以添加 )
当左右括号数量均达到 n 时，将当前路径 path 加入结果集

C++代码

class Solution
{
public:
    std::vector<std::string> res;   // 存储所有合法的括号组合
    std::string path;               // 当前生成的括号组合

    vector<string> generateParenthesis(int n)
    {
        dfs(n, 0, 0);               // 从 0 左括号和 0 右括号开始递归
        return res;
    }

    void dfs(int n, int l_p, int r_p)
    {
        // 如果左右括号都用完，生成一个合法组合
        if (l_p == n && r_p == n)
        {
            res.push_back(path);
            return;
        }

        // 尝试添加左括号
        if (l_p < n) {
            path.push_back('(');    // 添加左括号
            dfs(n, l_p + 1, r_p);  // 递归进入下一层
            path.pop_back();        // 回溯，移除左括号
        }

        // 尝试添加右括号
        if (r_p < n && r_p < l_p)
        {
            path.push_back(')');    // 添加右括号
            dfs(n, l_p, r_p + 1);  // 递归进入下一层
            path.pop_back();        // 回溯，移除右括号
        }
    }
};