Hang Zhang

Multiply Strings

Sun, 12 Apr 2026 00:00:00 +0000

43. Multiply Strings

Algorithm Steps

Iterate the array in reverse order
- Convert each character of num1 and num2 to integer, and store conversion results in integer array A and B
Simulate multiplication
- When multiplying 2 numbers of length n and m, the result has at most n + m digits
- Multiply A and B bit by bit accumulation，and store result in array C
  - C[i + j] = A[i] * B[j]
Handle carries
- Each digit of C is treated as unit digit, and the carry-over is accumulated to the next digit
Remove leading 0 and generate the result string
- Search for the first non-zero bit in the C from higher bit to the lower bit
- Convert the result array to string

Complexity Analysis

Length of num1 and num2 is n and m
Simulate multiplication O(n * m)
Handel carries and generate result string O(n + m)

Overall time complexity O(n * m)

Length of Result array C is n + m，space complexity O(n + m)

C++ Code

class Solution {
public:
    string multiply(string num1, string num2)
    {
        // get the length of num1 and num2
        int n = num1.size(), m = num2.size();

        // iterate the string in reverse order and convert to integer array
        std::vector<int> A, B;
        for (int i = n - 1; i >= 0; --i)
            A.push_back(num1[i] - '0');
        for (int i = m - 1; i >= 0; --i)
            B.push_back(num2[i] - '0');

        // initialize result array C
        std::vector<int> C(n + m, 0);

        // simulate multiplication
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                C[i + j] += A[i] * B[j];

        // handle carries
        for (int i = 0, t = 0; i < C.size(); ++i)
        {
            t += C[i];
            C[i] = t % 10;  // keep unit digit
            t /= 10;        // process carry part
        }

        // remove leading zeros
        int k = C.size() - 1;
        while (k > 0 && C[k] == 0) --k;

        // convert integer array to string
        std::string res;
        while (k >= 0)
            res += C[k--] + '0';

        return res;
    }
};

Python Code

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        n, m = len(num1), len(num2)

        A = [int(num1[i]) for i in range(n - 1, -1, -1)]
        B = [int(num2[i]) for i in range(m - 1, -1, -1)]

        C = [0] * (n + m)
        for i in range(n):
            for j in range(m):
                C[i + j] += A[i] * B[j]

        t = 0
        for i in range(len(C)):
            t += C[i]
            C[i] = t % 10
            t //= 10

        k = len(C) - 1
        while k > 0 and C[k] == 0:
            k -= 1

        res = ""
        while k >= 0:
            res += str(C[k])
            k -= 1

        return res

Go Code

func multiply(num1 string, num2 string) string {
    n, m := len(num1), len(num2)

    A := make([]int, n)
    B := make([]int, m)


    for i := 0; i < n; i ++ {
        A[i] = int(num1[n - 1 - i] - '0')
    }

    for i := 0; i < m; i ++ {
        B[i] = int(num2[m - 1 - i] - '0')
    }

    C := make([]int, n + m)
    for i := range A {
        for j := range B {
            C[i + j] += A[i] * B[j]
        }
    }

    t := 0
    for i := 0; i < len(C); i ++ {
        t += C[i]
        C[i] = t % 10
        t /= 10
    }

    k := len(C) - 1
    for k > 0 && C[k] == 0 {
        k -= 1
    }

    res := ""
    for k >= 0 {
        res += string(C[k] + '0')
        k -= 1
    }

    return res
}

JavaScript Code

/**
 * @param {string} num1
 * @param {string} num2
 * @return {string}
 */
var multiply = function (num1, num2) {
  let n = num1.length,
    m = num2.length;
  let A = [],
    B = [];

  for (let i = n - 1; i >= 0; i--) {
    A.push(Number(num1[i]));
  }

  for (let i = m - 1; i >= 0; i--) {
    B.push(Number(num2[i]));
  }

  let C = new Array(n + m).fill(0);
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < m; j++) {
      C[i + j] += A[i] * B[j];
    }
  }

  let t = 0;
  for (let i = 0; i < C.length; i++) {
    t += C[i];
    C[i] = t % 10;
    t = Math.trunc(t / 10);
  }

  let k = C.length - 1;
  while (k > 0 && C[k] === 0) {
    k--;
  }

  let res = "";
  while (k >= 0) {
    res += String(C[k--]);
  }

  return res;
};

Minimum Distance Between Three Equal Elements I

Sat, 11 Apr 2026 00:00:00 +0000

3740. Minimum Distance Between Three Equal Elements I

Algorithm Steps

Use map<int, vector<int>> to record all the indices of each element
For each index array p
- Enumerate the length >= 3
- Calculate (p[i] - p[i-2]) * 2
Take the minimum value

Complexity Analysis

Time complexity: O(n)

Space complexity: O(n)

Cpp Code

class Solution {
public:
    int minimumDistance(vector<int>& nums) {
        std::unordered_map<int, std::vector<int>> f;
        for (int i = 0; i < nums.size(); ++ i)
            f[nums[i]].push_back(i); // record all the indices of each element

        int res = INT_MAX;
        for (auto [_, p] : f) // iterate each index array
            for (int i = 2; i < p.size(); ++ i)
                res = std::min(res, (p[i] - p[i - 2]) * 2); // calculate minimum distance = 2 * (k - i)

        return res == INT_MAX ? -1 : res;
    }
};

Python Code

class Solution:
    def minimumDistance(self, nums: List[int]) -> int:
        f = {}
        for i, x in enumerate(nums):
            if x not in f:
                f[x] = []
            f[x].append(i)

        res = float('inf')
        for p in f.values():
            for i in range(2, len(p)):
                res = min(res, (p[i] - p[i - 2]) * 2)

        return -1 if res == float('inf') else res

Go Code

func minimumDistance(nums []int) int {
    f := make(map[int][]int)
    for i := 0; i < len(nums); i ++ {
        f[nums[i]] = append(f[nums[i]], i)
    }

    INF := 0x3f3f3f3f
    res := INF
    for _, p := range f {
        for i := 2; i < len(p); i ++ {
            if (p[i] - p[i - 2]) * 2 < res {
                res = (p[i] - p[i - 2]) * 2
            }
        }
    }

    if res == INF {
        return -1
    }

    return res
}

JavaScript Code

/**
 * @param {number[]} nums
 * @return {number}
 */
var minimumDistance = function (nums) {
  let f = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (!f.has(nums[i])) f.set(nums[i], []);
    f.get(nums[i]).push(i);
  }

  let res = Infinity;
  for (let p of f.values()) {
    for (let i = 2; i < p.length; i++) {
      res = Math.min(res, (p[i] - p[i - 2]) * 2);
    }
  }

  return res == Infinity ? -1 : res;
};

Number Conversion

Tue, 31 Mar 2026 00:00:00 +0000

数的进制转换

编写一个程序，可以实现将一个数字由一个进制转换为另一个进制。

这里有 62 个不同数位 {0−9,A−Z,a−z}。

输入格式

第一行输入一个整数，代表接下来的行数。

接下来每一行都包含三个数字，首先是输入进制（十进制表示），然后是输出进制（十进制表示），最后是用输入进制表示的输入数字，数字之间用空格隔开。

输入进制和输出进制都在 2 到 62 的范围之内。

（在十进制下）A=10，B=11，…，Z=35，a=36，b=37，…，z=61 (0−9 仍然表示 0−9)。

输出格式

对于每一组进制转换，程序的输出都由三行构成。

第一行包含两个数字，首先是输入进制（十进制表示），然后是用输入进制表示的输入数字。

第二行包含两个数字，首先是输出进制（十进制表示），然后是用输出进制表示的输入数字。

第三行为空白行。

同一行内数字用空格隔开。

输入样例：

8
62 2 abcdefghiz
10 16 1234567890123456789012345678901234567890
16 35 3A0C92075C0DBF3B8ACBC5F96CE3F0AD2
35 23 333YMHOUE8JPLT7OX6K9FYCQ8A

输出样例：

62 abcdefghiz
2 11011100000100010111110010010110011111001001100011010010001

10 1234567890123456789012345678901234567890
16 3A0C92075C0DBF3B8ACBC5F96CE3F0AD2

16 3A0C92075C0DBF3B8ACBC5F96CE3F0AD2
35 333YMHOUE8JPLT7OX6K9FYCQ8A

35 333YMHOUE8JPLT7OX6K9FYCQ8A
23 946B9AA02MI37E3D3MMJ4G7BL2F05

分析

使用字符串表示输入数字
将输入字符串转换为整型数组，每个元素表示一个数位，得到一个 a 进制的高精度数
遍历高精度数，每次对当前数位除以 b，余数（当前位），商（继续参与下一轮）
收集余数，每次的余数加入结果（低位 → 高位）
反转结果数组，再映射成字符串

时空复杂度

每一轮需要遍历整个整型数组 O(n)，总轮数 k，时间复杂度为 O(n * k)
整型数组占用 O(n)，结果数组占用 O(k)，空间复杂度为 O(n)

C++代码

#include <iostream>
#include <vector>
#include <algorithm>

std::string transform(int a, int b, std::string& a_line)
{
    // 字符串 -> a 进制数字数组
    std::vector<int> number;
    for (char c : a_line)
    {
        if (c >= '0' && c <= '9')
            number.push_back(c - '0');
        else if (c >= 'A' && c <= 'Z')
            number.push_back(c - 'A' + 10);
        else if (c >= 'a' && c <= 'z')
            number.push_back(c - 'a' + 36);
    }
    std::reverse(number.begin(), number.end()); // 低位在前，便于做高精度除法

    std::vector<int> res;

    // 循环：高精度数不断 ÷ b
    while (number.size())
    {
        int t = 0; // 当前余数
        for (int i = number.size() - 1; i >= 0; -- i)
        {
            number[i] = number[i] + t * a; // 当前位 + 上一位余数
            t = number[i] % b;             // 更新余数
            number[i] /= b;                // 更新商（保留用于下一轮）
        }

        res.push_back(t); // 收集余数（从低位到高位）

        // 去掉前导 0（避免无效计算）
        while (number.size() && number.back() == 0)
            number.pop_back();
    }

    std::reverse(res.begin(), res.end()); // 反转得到高位在前

    // 转回字符
    std::string b_line;
    for (int x : res)
    {
        if (x >= 0 && x <= 9)
            b_line += char(x + '0');
        else if (x >= 10 && x <= 35)
            b_line += char(x - 10 + 'A');
        else if (x >= 36 && x <= 61)
            b_line += char(x - 36 + 'a');
    }

    return b_line;
}

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

    while (n -- )
    {
        int a, b;
        std::string a_line, b_line;
        std::cin >> a >> b >> a_line;

        b_line = transform(a, b, a_line);

        std::cout << a << ' ' << a_line << std::endl;
        std::cout << b << ' ' << b_line << std::endl;
        std::cout << std::endl;
    }

    return 0;
}

Transform Array to All Equal Elements

Wed, 11 Jun 2025 00:00:00 +0000

3576. 数组元素相等转换

算法

每次操作可以翻转一对相邻元素的符号
为使所有元素相等，最终需要所有元素都是 1 或 -1
从左往右遍历数组，维护一个全局的乘积影响变量 mul（表示前面的操作对当前元素造成的正负反转）
遇到第 i 个元素与目标不符时（考虑乘积影响），对 i + 1 执行一次操作（乘以 -1）
统计所需的操作次数，若超过 k 或无法继续（要翻转的下一个元素不存在），则返回 false

复杂度分析

时间复杂度：O(n)
空间复杂度：O(1)

C++ 代码

class Solution {
public:
    // 尝试将所有元素变为 target（1 或 -1）
    bool checkTransform(std::vector<int>& nums, int k, int target) {
        int mul = 1;  // 表示之前操作对当前位置的影响（1为不变，-1为取反）
        for (int i = 0; i < nums.size(); ++ i) {
            if (nums[i] * mul == target) {
                mul = 1;  // 当前符合目标，不需要额外操作
                continue;
            }
            if (k == 0 || i == nums.size() - 1) {
                return false;  // 无法再操作，失败
            }
            -- k;       // 执行一次操作
            mul = -1;  // 接下来的元素将受到影响
        }
        return true;
    }

    bool canMakeEqual(vector<int>& nums, int k) {
        // 尝试变成全为 1 或全为 -1，两种都尝试
        return checkTransform(nums, k, 1) || checkTransform(nums, k, -1);
    }
};

Python 代码

class Solution:
    def checkTransform(self, nums, k, target):
        mul = 1
        for i in range(len(nums)):
            if nums[i] * mul == target:
                mul = 1
                continue
            if k == 0 or i == len(nums) - 1:
                return False
            k -= 1
            mul = -1
        return True

    def canMakeEqual(self, nums, k):
        return self.checkTransform(nums, k, 1) or self.checkTransform(nums, k, -1)

Go 代码

func checkTransform(nums []int, k int, target int) bool {
    mul := 1
    for i := 0; i < len(nums); i ++ {
        if nums[i] * mul == target {
            mul = 1
            continue
        }
        if k == 0 || i == len(nums) - 1 {
            return false
        }
        k --
        mul = -1
    }
    return true
}

func canMakeEqual(nums []int, k int) bool {
    return checkTransform(nums, k, 1) || checkTransform(nums, k, -1)
}

JavaScript 代码

var canMakeEqual = function (nums, k) {
  function checkTransform(nums, k, target) {
    let mul = 1;
    for (let i = 0; i < nums.length; ++i) {
      if (nums[i] * mul == target) {
        mul = 1;
        continue;
      }
      if (k == 0 || i == nums.length - 1) {
        return false;
      }
      k--;
      mul = -1;
    }
    return true;
  }

  return checkTransform(nums, k, 1) || checkTransform(nums, k, -1);
};

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))
}

Remove Duplicates from Sorted Array II

Sun, 25 May 2025 00:00:00 +0000

80. 删除有序数组中的重复项II

分析

双指针：

指针 i 表示当前处理后数组的有效长度
每次从前往后扫描数组元素 x，如果 x 与 nums[i - 1] 和 nums[i - 2] 不同时（即还没出现两次），就可以保留它
否则跳过该元素

C++代码

class Solution
{
public:
    int removeDuplicates(vector<int>& nums)
    {
      int i = 0; // 写指针，记录当前可以写入的位置
      for (int x : nums) // 遍历每个元素
        if (i < 2 || (nums[i - 1] != x || nums[i - 2] != x))  // 若前面不足两个元素，或当前元素不等于前两个元素 -> 可以保留
          nums[i ++ ] = x; // 将当前元素写入位置 i，并自增 i
      return i; // 返回有效数组长度
    }
};

时间复杂度

每个元素只遍历一次：O(n)

空间复杂度

O(1)

Reverse Linked List II

Wed, 21 May 2025 00:00:00 +0000

92. 反转链表II

分析

创建一个虚拟头节点 dummy，它的 next 指向 head，简化边界情况处理（如 left = 1）
用指针 p 找到 left 节点的前一个节点
从 p->next 开始反转区间 [left, right] 的节点，采用头插法实现
反转完成后，将前后链表重新接好

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    ListNode* reverseBetween(ListNode* head, int left, int right)
    {
      ListNode* dummy = new ListNode(-1); // 创建虚拟头节点，简化边界处理
      dummy->next = head;

      ListNode* p = dummy;
      // 将 p 移动到 left 前一个节点的位置
      for (int i = 0; i < left - 1; ++ i)
        p = p->next;

      // 初始化要反转的部分的起始节点
      ListNode *prev = p->next, *cur = prev->next;

      // 头插法反转 [left, right] 区间
      for (int i = 0; i < right - left; ++ i)
      {
        ListNode *next = cur->next; // 暂存下一个节点
        cur->next = prev;           // 当前节点指向前一个节点
        prev = cur, cur = next;     // 向前推进指针
      }

      // 拼接反转后的子链表与剩余链表
      ListNode *q = p->next; // 反转前的 left 节点，反转后变成尾部
      p->next = prev;        // p 指向反转后的头部
      q->next = cur;         // 原 left 节点指向反转后剩余的部分

      return dummy->next;    // 返回新链表头节点
    }
};

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;
    }
};

Rotate String

Tue, 13 May 2025 00:00:00 +0000

796. 旋转字符串

分析

s + s 包含 s 所有可能的旋转结果，把 s + s 作为一个整体，在其中查找是否存在 goal 子串

时间复杂度

时间复杂度 O(n)，find 操作在最坏情况下是 O(n^2)，但在实际实现中通常会做优化

空间复杂度

空间复杂度 O(n)

C++代码

class Solution
{
public:
    bool rotateString(string s, string goal)
    {
        // 判断长度是否相等，并且 goal 是否是 s + s 的子串
        return s.size() == goal.size() && (s + s).find(goal) != std::string::npos;
    }
};

Angle Between Hands of Clock

Sun, 11 May 2025 00:00:00 +0000

1344. 时钟指针的夹角

分析

在一个圆形时钟上：
- 分针每分钟转动 6°（360° ÷ 60）
- 时针每小时转动 30°（360° ÷ 12），并且每分钟还会向前转动 0.5°（30° ÷ 60min），即 minutes * 0.5° 。
因此可以计算：
- 分针的角度为：a = minutes * 6
- 时针的角度为：b = hour * 30 + minutes * 0.5
两者的夹角是 |a - b|，但由于时钟是圆形，返回较小的那个角度 std::min(std::abs(a - b), 360 - std::abs(a - b))

时间复杂度

时间复杂度 O(1)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    double angleClock(int hour, int minutes)
    {
        // 将 hour 统一为 12 小时制
        hour %= 12;

        // 分针的角度（每分钟 6 度）
        double a = minutes * 6;

        // 时针的角度（每小时 30 度 + 每分钟 0.5 度）
        double b = hour * 30 + minutes * 0.5;

        // 返回两个角度的较小值
        return std::min(std::abs(a - b), 360 - std::abs(a - b));
    }
};

Implement Queue Using Stacks

Sat, 10 May 2025 00:00:00 +0000

232. 栈实现队列

分析

使用两个栈：
- stk：用于存储新加入的元素（输入栈）
- cache：用于临时反转栈 stk 中的顺序，以模拟队列的出队（输出栈）
实现方式：
- push(x)：直接压入 stk
- pop() / peek()：
  1. 把 stk 中的所有元素依次压入 cache，此时顺序反转
  2. cache.top() 就是队列头部元素
  3. 取出元素后，再把所有元素放回 stk，保持结构还原
- empty()：只需判断 stk 是否为空

时间复杂度

push(): O(1)
pop()/peek(): O(n)
empty(): O(1)

C++代码

class MyQueue
{
public:
    std::stack<int> stk, cache; // stk是输入栈，cache是输出栈

    MyQueue() {}

    void push(int x)
    {
        stk.push(x); // 直接压入输入栈
    }

    int pop()
    {
        // 将 stk 中所有元素转移到 cache 中
        while (stk.size())
        {
            cache.push(stk.top());
            stk.pop();
        }
        int x = cache.top(); // 弹出队头元素
        cache.pop();

        // 将剩余元素放回 stk
        while (cache.size())
        {
            stk.push(cache.top());
            cache.pop();
        }
        return x;
    }

    int peek()
    {
        while (stk.size())
        {
            cache.push(stk.top());
            stk.pop();
        }
        int x = cache.top(); // 查看队头元素但不删除

        while (cache.size())
        {
            stk.push(cache.top());
            cache.pop();
        }
        return x;
    }

    bool empty()
    {
        return stk.empty();
    }
};

// 优化，引入惰性转移（懒加载）策略，只在 cache 为空时才转移元素
class MyQueue
{
public:
    std::stack<int> stk, cache;

    MyQueue() {}

    void push(int x)
    {
        stk.push(x);
    }

    int pop()
    {
        if (cache.empty())
        {
            while (!stk.empty())
            {
                cache.push(stk.top());
                stk.pop();
            }
        }
        int x = cache.top();
        cache.pop();
        return x;
    }

    int peek()
    {
        if (cache.empty())
        {
            while (!stk.empty())
            {
                cache.push(stk.top());
                stk.pop();
            }
        }
        return cache.top();
    }

    bool empty()
    {
        return stk.empty() && cache.empty();
    }
};

Implement Stack Using Queues

Sat, 10 May 2025 00:00:00 +0000

225. 用队列实现栈

分析

每次访问栈顶元素 top() 或弹出栈顶元素 pop() 时，先将队列中的前 size - 1 个元素重新入队，从而把「最后加入的元素」移动到队头，模拟栈顶

push(): O(1)
pop(): O(n)
top(): O(n)
empty(): O(1)

时间复杂度

排序复杂度：O(nlogn)
三重循环复杂度：外层循环 O(n)，内层双指针 O(n)，总复杂度为 O(n^2)

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

C++代码

class MyStack
{
public:
    std::queue<int> q;

    MyStack() {}

    // 压栈：直接将元素压入队列末尾
    void push(int x)
    {
        q.push(x);
    }

    // 弹栈：将前 size - 1 个元素移至队尾，留下最后一个元素弹出
    int pop()
    {
        int size = q.size();
        while (size-- > 1)
        {
            q.push(q.front());
            q.pop();
        }
        int x = q.front();
        q.pop();
        return x;
    }

    // 查看栈顶：逻辑与 pop 类似，但最后将该元素重新压入队尾
    int top()
    {
        int size = q.size();
        while (size-- > 1)
        {
            q.push(q.front());
            q.pop();
        }
        int x = q.front();
        q.pop();
        q.push(x);
        return x;
    }

    // 判空：直接判断队列是否为空
    bool empty()
    {
        return q.empty();
    }
};

Longest Continuous Increasing Subsequence

Sat, 26 Apr 2025 00:00:00 +0000

674. 最长连续递增序列

分析

初始化 res = 0 表示最长递增子序列长度
用变量 i 从头开始遍历数组，每次以 i 为起点
用 j 向右扩展，直到不满足递增条件
当前递增区间长度为 j - i，更新最大值
下次从 j 开始继续找下一段

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    int findLengthOfLCIS(vector<int>& nums)
    {
        int res = 0;
        for (int i = 0; i < nums.size(); ++ i)
        {
            int j = i + 1;
            // 找到从 i 开始最长的连续递增序列
            while (j < nums.size() && nums[j - 1] < nums[j])
                ++ j;
            res = std::max(res, j - i); // 更新最大长度
            i = j - 1;                  // 跳过已经检查过的部分
        }
        return res;
    }
};

Minimum Subsequence in Non Increasing Order

Sat, 26 Apr 2025 00:00:00 +0000

1403. 非递增顺序的最小子序列

分析

元素大的更容易让子序列之和更快超过剩余元素之和，将数组降序排序
贪心策略：从大到小依次取元素，直到当前子序列的和严格超过剩余元素的和
由于优先取大的元素，自然能保证子序列长度最小、元素和最大，且结果是非递增排序的

时间复杂度

时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> minSubsequence(vector<int>& nums)
    {
        std::vector<int> res;
        std::sort(nums.begin(), nums.end(), std::greater()); // 1. 降序排序

        int sum = 0;
        for (int x : nums)
            sum += x; // 2. 计算总和

        int cur = 0;
        for (int x : nums)
        {
            cur += x;             // 当前子序列的和
            res.push_back(x);      // 加入子序列
            if (cur + cur > sum)   // 当前子序列和 > 剩余元素和
                break;
        }
        return res;
    }
};

Monotone Increasing Digits

Sat, 26 Apr 2025 00:00:00 +0000

738. 单调递增的数字

分析

将 n 转换为字符串 s
找到 第一个下降的位置，即前一位大于后一位
为了让整体数值最大:
- 将下降点前一个位置的数减 1
  - 注意：如果前面有连续相同的数字，需要往前找到第一个不同的数字再减 1
- 后面的所有位数填成 '9'

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(n)

C++代码

class Solution
{
public:
    int monotoneIncreasingDigits(int n)
    {
        std::string s = std::to_string(n);
        int k = 0;

        // 先找到第一个下降的位置
        while (k + 1 < s.size() && s[k] <= s[k + 1])
            ++ k;

        // 如果本身已经是单调递增，直接返回 n
        if (k == s.size() - 1)
            return n;

        // 否则，需要回退到第一个不同的位置
        while (k && s[k] == s[k - 1])
            -- k;

        // 将第 k 位减 1
        s[k] -= 1;

        // 将 k+1 及之后的位置全部置为 '9'
        for (int i = k + 1; i < s.size(); ++ i)
            s[i] = '9';

        return std::stoi(s);
    }
};

Non Decreasing Subsequences

Sat, 26 Apr 2025 00:00:00 +0000

491. 非递减子序列

分析

path 数组记录当前构建中的子序列
每当 path 长度大于等于 2，就加入答案集
每次从下标 u 开始向后枚举所有可能的数字：
- 若当前数字 nums[i] 可以接在 path 的末尾（即递增），就加入递归
- 用一个哈希集合 S 记录当前层用过的数字，避免同一层出现重复元素（防止结果中出现重复子序列）

时间复杂度

时间复杂度 O(2^n)

空间复杂度

空间复杂度 O(n)

C++代码

class Solution
{
public:
    std::vector<std::vector<int>> res; // 存储所有结果
    std::vector<int> path;             // 当前构建中的子序列

    void dfs(std::vector<int>& nums, int u)
    {
        // 如果子序列长度 >= 2，就加入结果集
        if (path.size() >= 2)
            res.push_back(path);

        if (u == nums.size()) return;

        std::unordered_set<int> S; // 当前层去重

        for (int i = u; i < nums.size(); ++ i)
        {
            // 满足递增条件且未在本层用过
            if ((path.empty() || path.back() <= nums[i]) && !S.count(nums[i]))
            {
                S.insert(nums[i]);      // 标记本层已使用
                path.push_back(nums[i]);
                dfs(nums, i + 1);       // 递归下一个位置
                path.pop_back();        // 回溯
            }
        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums)
    {
        dfs(nums, 0);
        return res;
    }
};

Partition Array Into Disjoint Intervals

Sat, 26 Apr 2025 00:00:00 +0000

915. 分割数组

分析

从右往左预处理出数组 r[i]，表示从位置 i 到末尾的最小值
遍历查找分界点：
- 从左往右遍历，用变量 l 记录当前 left 的最大值
- 每到一个位置，检查 l <= r[i + 1]，如果满足，说明当前划分是合法的，可以返回当前 left 的长度

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(n)

C++代码

class Solution
{
public:
    int partitionDisjoint(vector<int>& nums)
    {
        int n = nums.size();
        std::vector<int> r(n);
        r[n - 1] = nums[n - 1]; // 1. 初始化最右边元素
        for (int i = n - 2; i >= 0; --i)
            r[i] = std::min(nums[i], r[i + 1]); // 2. 预处理右边最小值数组

        int l = INT_MIN;
        for (int i = 0; i + 1 < n; ++i)
        {
            l = std::max(l, nums[i]); // 3. 记录左边最大值
            if (l <= r[i + 1])         // 4. 检查是否满足条件
                return i + 1;
        }
        return 0;
    }
};

Partition to K Equal Sum Subsets

Fri, 25 Apr 2025 00:00:00 +0000

698. 划分为k个相等的子集

分析

目标和计算：
- 若 sum % k != 0，无法平均分配，直接返回 false
- 每个子集的目标和为 target = sum / k
DFS 搜索状态：
- 从第 u 个元素开始，递归地尝试将当前元素加入某个子集
- 当前子集的和为 cur，如果正好等于 target，递归下一个子集k - 1
- 使用 st[i] 记录第 i 个元素是否已被使用
剪枝优化：
- 排序数组后，跳过相同的数字，避免重复搜索
- 当前 cur + nums[i] > target 时剪枝

时间复杂度

时间复杂度 O(k * 2^n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int target = 0;               // 每个子集的目标和
    std::vector<bool> st;        // 标记数组：记录元素是否被使用

    // 回溯搜索函数
    bool dfs(std::vector<int>& nums, int u, int cur, int k)
    {
        if (k == 0) return true;                        // 成功划分成 k 个子集
        if (cur == target)                              // 当前子集满了，开始下一个
            return dfs(nums, 0, 0, k - 1);

        for (int i = u; i < nums.size(); ++ i)
        {
            if (!st[i])
            {
                if (cur + nums[i] <= target)            // 不超过目标和
                {
                    st[i] = true;
                    if (dfs(nums, i + 1, cur + nums[i], k))
                        return true;
                    st[i] = false;                      // 回溯
                }

                // 跳过重复数字，避免冗余递归
                while (i + 1 < nums.size() && nums[i] == nums[i + 1])
                    ++ i;
            }
        }
        return false;
    }

    bool canPartitionKSubsets(vector<int>& nums, int k)
    {
        int sum = 0;
        for (int x : nums) sum += x;
        if (sum % k) return false;                      // 不能整除，无法划分

        target = sum / k;
        st = std::vector<bool>(nums.size());

        sort(nums.begin(), nums.end());                 // 优化搜索顺序（方便剪枝）
        return dfs(nums, 0, 0, k);
    }
};

Validate IP Address

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

468. 验证IP地址

分析

IPv4 的验证规则：
- 总共有 4 段，以 . 分隔
- 每一段不能为空，也不能超过 4 位
- 每一段不能有前导零（如 01 是非法的）
- 每一段只能包含数字字符
- 每一段是 0 到 255 的十进制数字
IPv6 的验证规则：
- 总共有 8 段，以 : 分隔
- 每一段不能为空，也不能超过 4 位
- 每一段是 1 ~ 4 个十六进制字符（0 - 9, a - f, A - F）

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    // 字符串分割函数
    std::vector<std::string> split(std::string ip, char sep)
    {
        std::vector<std::string> items;
        for (int i = 0; i < ip.size(); ++ i)
        {
            int j = i;
            std::string item;
            // 提取每段内容直到遇到分隔符
            while (ip[j] != sep)
                item += ip[j ++ ];
            items.push_back(item);
            i = j;
        }
        return items;
    }

    // IPv4 验证函数
    std::string check_ipv4(std::string ip)
    {
        std::vector<std::string> items = split(ip + '.', '.'); // 加一个终止符避免遗漏最后一段
        if (items.size() != 4) return "Neither";
        for (auto item : items)
        {
            if (item.empty() || item.size() > 3) return "Neither";
            if (item.size() > 1 && item[0] == '0') return "Neither";  // 不允许前导0
            for (auto c : item)
                if (c < '0' || c > '9') return "Neither";
            if (std::stoi(item) > 255) return "Neither";
        }
        return "IPv4";
    }

    // IPv6 合法字符判断
    bool check_ch(char c)
    {
        if (c >= '0' && c <= '9') return true;
        if (c >= 'a' && c <= 'f') return true;
        if (c >= 'A' && c <= 'F') return true;
        return false;
    }

    // IPv6 验证函数
    std::string check_ipv6(std::string ip)
    {
        std::vector<std::string> items = split(ip + ':', ':');
        if (items.size() != 8) return "Neither";
        for (auto item : items)
        {
            if (item.empty() || item.size() > 4) return "Neither";
            for (auto c : item)
                if (!check_ch(c)) return "Neither";
        }
        return "IPv6";
    }

    // 主函数，根据分隔符判断格式
    string validIPAddress(string queryIP)
    {
        if (queryIP.find('.') != -1 && queryIP.find(':') != -1) return "Neither"; // 同时包含 . 和 :
        if (queryIP.find('.') != -1) return check_ipv4(queryIP);
        if (queryIP.find(':') != -1) return check_ipv6(queryIP);
        return "Neither";
    }
};

Maximum Swap

Sat, 19 Apr 2025 00:00:00 +0000

670. 最大交换

分析

将数字转为字符串，方便逐位操作；
从左往右找到第一个不是降序的拐点，记为 i，即 s[i] < s[i + 1]
- 说明从这一位起，后面可能有更大的数字
从该拐点 i + 1 向右寻找最大的数字，且取最靠右的那个最大值（使前面替换的数字尽量大）
然后从左到右找到第一个比这个最大值小的数字，交换两者
由于只交换一次，直接返回交换后的值即可
如果整个数字是降序排列的，说明已经是最大值，直接返回原值

时间复杂度

时间复杂度 O(n^2)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maximumSwap(int num)
    {
        std::string s = std::to_string(num); // 转换为字符串方便操作

        for (int i = 0; i + 1 < s.size(); ++ i)
        {
            if (s[i] < s[i + 1])  // 找到第一个非降序的位置
            {
                int k = i + 1;
                // 找到从 i + 1 开始最大的数字，取最靠右的那个（保证交换尽可能早的位）
                for (int j = k + 1; j < s.size(); ++ j)
                    if (s[k] <= s[j])
                        k = j;

                // 从左到右找第一个比 s[k] 小的数，交换
                for (int j = 0; ; ++ j)
                    if (s[j] < s[k])
                    {
                        std::swap(s[j], s[k]);
                        return std::stoi(s);  // 返回交换后的整数
                    }
            }
        }

        return num;  // 如果没有找到下降点，原数就是最大值
    }
};

Remove Duplicate Node

Fri, 18 Apr 2025 00:00:00 +0000

移除重复节点

分析

使用一个哈希集合 hash 来存储链表中已经出现的数值
用两个指针：
- pre：当前保留的最后一个节点；
- cur：正在检查的下一个节点；
如果 cur->val 已经在 hash 中出现过，说明是重复节点：
- 将 pre->next 指向 cur->next，跳过当前节点
否则：
- 将该值加入 hash，并正常前进两个指针；
遍历完整个链表后返回 head

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    ListNode* removeDuplicateNodes(ListNode* head)
    {
        if (!head || !head->next)
            return head;  // 空链表或单节点链表直接返回

        ListNode *pre = head, *cur = head->next;
        std::unordered_set<int> hash;
        hash.insert(pre->val);  // 将头结点的值加入哈希集合

        while (cur)
        {
            if (hash.count(cur->val))  // 当前节点值已出现，跳过该节点
            {
                pre->next = cur->next;
                cur = pre->next;
            }
            else  // 新值，保留该节点
            {
                hash.insert(cur->val);
                pre = cur;
                cur = cur->next;
            }
        }

        return head;
    }
};

Compress String

Thu, 17 Apr 2025 00:00:00 +0000

字符串压缩

分析

使用变量 cnt 记录当前字符的连续出现次数；
遍历字符串，统计连续相同字符的个数；
每当遇到下一个字符不同（或到字符串结尾）时，就把当前字符和它的个数拼接到结果字符串中；
最后判断压缩后的结果是否更短，是则返回压缩结果，否则返回原字符串

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    string compressString(string s)
    {
        std::string res;  // 存储压缩后的字符串
        int cnt = 0;      // 当前字符的计数

        for (int i = 0; i < s.size(); ++ i)
        {
            ++cnt;

            // 如果当前字符是最后一个，或与下一个字符不同，就拼接
            if (i + 1 == s.size() || s[i] != s[i + 1])
            {
                res += s[i];               // 添加当前字符
                res += std::to_string(cnt); // 添加出现次数
                cnt = 0;                   // 重置计数器
            }
        }

        // 如果压缩结果更短，返回压缩结果，否则返回原字符串
        return res.size() < s.size() ? res : s;
    }
};

Is Unique

Thu, 17 Apr 2025 00:00:00 +0000

判断字符是否唯一

分析

用一个整型变量 check 作为位掩码（bitmask），其每一位表示一个字符是否出现
遍历字符串中的每个字符：
- 如果该字符之前出现过（对应位为 1），说明不唯一，返回 false
- 否则将对应位设为 1
遍历完成仍未发现重复，返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    bool isUnique(string astr)
    {
        int check = 0;  // 位掩码，初始为 0

        for (char c : astr)
        {
            // 计算字符在字母表中的索引位置（0~25）
            int bit = c - 'a';

            // 如果对应位已为 1，说明重复
            if (check & (1 << bit))
                return false;

            // 否则将该位置为 1
            check |= (1 << bit);
        }

        // 所有字符都不同
        return true;
    }
};

String to Url

Thu, 17 Apr 2025 00:00:00 +0000

URL化

分析

从末尾位置 k 开始往前填充字符
从实际字符串末尾 length - 1 开始向前遍历：
- 若遇到普通字符，则复制到末尾
- 若遇到空格 ' '，则插入 '%20'
最后返回处理后的子串 s.substr(k + 1) 即可

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    string replaceSpaces(string s, int length)
    {
        int k = s.size() - 1;  // k 指向字符串的最末尾（即原始字符串+预留空间）

        // 从真实长度的尾部开始往前处理
        for (int i = length - 1; i >= 0; --i)
        {
            if (s[i] == ' ')  // 空格替换为 "%20"
            {
                s[k--] = '0';
                s[k--] = '2';
                s[k--] = '%';
            }
            else  // 普通字符直接移动
            {
                s[k--] = s[i];
            }
        }

        // 截取有效部分返回
        return s.substr(k + 1);
    }
};

Maximum Contiguous Subsequence

Thu, 10 Apr 2025 00:00:00 +0000

最大连续子序列

给定 K 个整数的序列 {N0, N1, …, NK − 1}，其任意连续子序列可表示为 {Ni, Ni + 1, …, Nj}，其中 0 ≤ i ≤ j < K

最大连续子序列是所有连续子序列中元素和最大的一个，例如给定序列 {−2, 11, −4, 13, −5, −2}，其最大连续子序列为 {11, −4, 13} ，最大和为 20

编写程序得到其中最大子序列的和并输出该子序列的第一个和最后一个元素的下标

输入格式

输入包含多组测试数据

每组数据占 2 行，第 1 行给出正整数 K

第 2 行给出 K 个整数 N1, …, NK

输出格式

每组数据输出一行结果，包含最大子序列的和以及子序列的第一个下标 i 和最后一个元素的下标 j

所有元素下标为 0 ∼ K − 1

如果最大子序列不唯一，则选择 i 最小的那个子序列，如果仍不唯一，则选择 i 最小的子序列中 j 最小的那个子序列

若所有 K 个元素都是负数，则定义其最大和为 0，输出 0 0 0

数据范围

1 ≤ K ≤ 105, −10000 ≤ Ni ≤ 10000, 输入最多包含 10 组数据

输入样例：

8
6 -2 11 -4 13 -5 -2 10
5
10 -10 10 -10 10
8
-1 -5 -2 3 -1 0 -2 0
4
-1 -2 -4 -3

输出样例：

分析

last：当前以第 i 个元素结尾的子序列最大和
若 last < 0，则从当前元素重新开始，记录当前左端点 temp
如果当前 last 优于全局最大 res，则更新 res 和左右端点

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

#include <iostream>
#include <climits>

const int N = 100010;
int nums[N];

int main()
{
  int n;

  while (std::cin >> n)
  {
    for (int i = 0; i < n; ++i)
      std::cin >> nums[i];

    int last = 0;                   // 当前子段和
    int res = INT_MIN;             // 最大子段和
    int l = 0, r = 0;              // 结果子序列的起止下标
    int temp = 0;                  // 记录当前子段的起点

    for (int i = 0; i < n; ++i)
    {
      // 如果前缀和为负，丢弃，重开新子段，并记录左端点
      if (last < 0)
        temp = i;

      last = std::max(nums[i], last + nums[i]);

      if (res < last)
      {
        res = last;
        l = temp;                  // 更新起点为当前有效起点
        r = i;                     // 终点为当前下标
      }
    }

    if (res < 0)
      std::cout << "0 0 0" << '\n';  // 所有数都为负数
    else
      std::cout << res << ' ' << l << ' ' << r << '\n';
  }

  return 0;
}

Dijkstra Finding the Shortest Path II

Sat, 05 Apr 2025 00:00:00 +0000

Dijkstra 求最短路II

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值

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

输入格式

第一行包含整数 n 和 m
接下来 m 行每行包含三个整数 x, y, z，表示存在一条从点 x 到点 y 的有向边，边长为 z

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离
如果路径不存在，则输出 −1

数据范围

1 ≤ n, m ≤ 150000
图中涉及边长均不超过 10000

输入样例

输出样例

分析

n的范围变为 1 ~ 150000，属于稀疏图（点多边少），采用 邻接表 + 堆优化

图初始化
- 使用邻接表建图，每次调用 add(a, b, c) 记录一条边
Dijkstra 主体逻辑
- 起点 1 入堆，距离设为 0
- 每次从堆中取出距离最小的点 ver，如果该点已确定最短路则跳过
- 遍历 ver 的所有出边 ver → j：
  - 若 dist[j] > dist[ver] + w，说明找到了更短路径，更新并入堆
输出答案
- 若 dist[n] == INF，说明无法到达 n，输出 -1
- 否则输出 dist[n]

时间复杂度

时间复杂度 O(mlogn)

空间复杂度

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

C++代码

#include <cstring>
#include <iostream>
#include <queue>
#include <utility>

typedef std::pair<int, int> PII;  // <最短距离, 点编号>

const int N = 1000010;
const int INF = 0x3f3f3f3f;

int h[N], e[N], w[N], ne[N], idx; // 邻接表
int dist[N];      // 存储最短距离
bool st[N];       // 标记是否已经确定最短距离
int n, m;

// 添加一条边 a -> b，权值为 c
void add(int a, int b, int c)
{
  e[idx] = b;
  w[idx] = c;
  ne[idx] = h[a];
  h[a] = idx++;
}

// 堆优化 Dijkstra 主函数
int dijkstra() {
  std::memset(dist, INF, sizeof(dist));
  dist[1] = 0;

  std::priority_queue<PII, std::vector<PII>, std::greater<PII>> heap;
  heap.push({0, 1}); // 起点入堆

  while (heap.size())
  {
    PII t = heap.top();
    heap.pop();
    int ver = t.second;

    if (st[ver]) continue;  // 如果已经处理过，跳过
    st[ver] = true;

    // 遍历 ver 的所有出边
    for (int i = h[ver]; i != -1; i = ne[i])
    {
      int j = e[i];
      if (dist[j] > dist[ver] + w[i])
      {
        dist[j] = dist[ver] + w[i];
        heap.push({dist[j], j});
      }
    }
  }

  return dist[n] == INF ? -1 : dist[n];
}

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

  std::cin >> n >> m;
  for (int i = 0; i < m; ++ i)
  {
    int x, y, z;
    std::cin >> x >> y >> z;
    add(x, y, z);  // 构建图
  }

  std::cout << dijkstra() << '\n';

  return 0;
}

Dijkstra Finding the Shortest Path I

Fri, 04 Apr 2025 00:00:00 +0000

Dijkstra 求最短路I

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值

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

输入格式

第一行包含整数 n 和 m
接下来 m 行每行包含三个整数 x, y, z，表示存在一条从点 x 到点 y 的有向边，边长为 z

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离
如果路径不存在，则输出 −1

数据范围

1 ≤ n ≤ 500
1 ≤ m ≤ 105
图中涉及边长均不超过 10000

输入样例

输出样例

分析

初始化
- dist[i] 记录从起点 1 到 i 的最短路径，初始化为 INF（无穷大）
- st[i] 记录该点是否已确定最短路径，初始化为 false
- g[i][j] 记录 i 到 j 的边权，初始化为 INF
Dijkstra 算法执行
- 选取当前未确定最短路径且距离最近的点 t
- 将 t 标记为已确定 (st[t] = true)
- 遍历 t 的所有邻接点 j，如果 dist[t] + g[t][j] < dist[j]，更新 dist[j]
- 重复 n 轮，直到所有点处理完
返回结果
- 如果 dist[n] == INF，说明无法到达 n，返回 -1
- 否则返回 dist[n]，即 1 号点到 n 号点的最短路径长度

时间复杂度

寻找最小 dist[t] 的点：O(n)
遍历所有边更新 dist[j]：O(n^2)

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

空间复杂度

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

C++代码

#include <cstring>
#include <iostream>

const int N = 510;
const int INF = 0x3f3f3f3f;

int g[N][N];  // 邻接矩阵存储图
int dist[N];  // 记录最短路径距离
bool st[N];   // 记录该点是否已确定最短路径

int n, m;  // n个点，m条边

int dijkstra()
{
    std::memset(dist, INF, sizeof(dist));
    dist[1] = 0;  // 起点1号点，最短路径初始化为0

    for (int i = 0; i < n; ++i)
    {
        // 选取当前未确定的点中，dist最小的点 t
        int t = -1;
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dist[j] < dist[t]))
                t = j;

        st[t] = true;  // 标记 t 号点已经确定最短路径

        // 用 t 号点更新其他点的最短距离
        for (int j = 1; j <= n; ++j)
            dist[j] = std::min(dist[j], dist[t] + g[t][j]);
    }

    return dist[n] == INF ? -1 : dist[n];  // 如果 n 号点仍是 INF，说明无法到达
}

int main()
{
    std::memset(g, INF, sizeof(g));  // 初始化邻接矩阵，所有边初始设为无穷大

    std::cin >> n >> m;
    while (m--)
    {
        int x, y, z;
        std::cin >> x >> y >> z;
        g[x][y] = std::min(g[x][y], z);  // 处理重边，取最小值
    }

    std::cout << dijkstra() << '\n';

    return 0;
}

Reorder List

Fri, 04 Apr 2025 00:00:00 +0000

143. 重排链表

分析

第一步：找到链表的中点
- 遍历链表长度，再通过 (len + 1) / 2 找到中间节点位置
第二步：反转链表后半段
- 从中点开始，原地反转链表后半段
第三步：合并两段链表
- 将前半段和后半段反转后的链表进行交叉合并
- 注意尾指针的处理，避免无限循环

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    void reorderList(ListNode* head)
    {
        if (!head) return;

        // 1. 统计链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 2. 找到链表中点
        ListNode* mid = head;
        for (int i = 0; i < (len + 1) / 2 - 1; ++i)
            mid = mid->next;

        // 3. 反转链表后半部分
        ListNode *a = mid, *b = mid->next;
        for (int i = 0; i < len / 2; ++i)
        {
            ListNode* c = b->next;
            b->next = a;
            a = b;
            b = c;
        }

        // 4. 合并两段链表
        ListNode *p = head, *q = a;
        for (int i = 0; i < len / 2; ++i)
        {
            ListNode* o = q->next;
            q->next = p->next;
            p->next = q;

            if (len % 2 == 0 && i == len / 2 - 1)
                q->next = nullptr;

            q = o;
            p = p->next->next;
        }

        if (len % 2 == 1)
            p->next = nullptr;
    }
};

Defanging an IP Address

Thu, 03 Apr 2025 00:00:00 +0000

1108. IP地址无效化

分析

遍历字符串，逐个检查字符
如果是 '.' ，就将其替换为 "[.]"
否则，直接添加到新字符串中

时间复杂度

时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    string defangIPaddr(string address)
    {
      std::string res;  // 存储转换后的字符串
      for (char c : address)   // 遍历输入字符串
        if (c == '.')
          res += "[.]";  // 遇到 '.' 时替换为 "[.]"
        else
          res += c;  // 其他字符直接加入结果字符串
      return res;
    }
};

Restore IP Address

Thu, 03 Apr 2025 00:00:00 +0000

93. 复原IP地址

分析

有效 IP 地址的要求
- 由 4 个整数组成（范围 0 ~ 255）
- 整数之间用 . 分隔
- 不能有前导 0（如 "01" 是非法的）
- 所有字符必须被使用
dfs 递归逻辑
- u：当前扫描到的字符索引
- k：当前已解析出的 IP 段数
- path：当前已拼接的 IP 地址（尚未去除最后一个 .）
- 递归终止条件：
  - u == s.size()：如果字符串已经完全遍历：
    - 如果 k == 4，说明成功找到一个 IP 地址，去掉最后一个 .，加入结果集 res
    - 否则，返回（分段不足 4 段）
  - 如果 k == 4 且 s 还未遍历完，返回
遍历 1 ~ 3 位
- 循环遍历 i = u 到 i < s.size()，每次尝试截取 1 ~ 3 位：
  - 若存在前导 0，停止搜索
  - 转换成整数 t：t = t * 10 + s[i] - '0'
  - 如果 t > 255，停止搜索（数字超出 IP 地址范围）
  - 递归调用 dfs，继续尝试下一段

时间复杂度

最多有 4 段，每段最多 3 种选择，时间复杂度 O(3^4)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    std::vector<std::string> res;  // 存放所有合法 IP 地址

    void dfs(std::string& s, int u, int k, std::string path)
    {
        if (u == s.size())  // 如果字符串已遍历完
        {
            if (k == 4)  // 且正好分成了 4 段
            {
                path.pop_back();  // 去掉最后一个 '.'
                res.push_back(path);  // 加入结果集
            }
            return;
        }

        if (k == 4)  // 超过 4 段，直接返回
            return;

        for (int i = u, t = 0; i < s.size(); ++i)
        {
            if (i > u && s[u] == '0')  // 不能有前导 0
                break;

            t = t * 10 + s[i] - '0';  // 将字符转换成整数

            if (t > 255)  // 超出 255，直接停止
                break;

            dfs(s, i + 1, k + 1, path + std::to_string(t) + '.');  // 递归
        }
    }

    vector<string> restoreIpAddresses(string s)
    {
        dfs(s, 0, 0, "");
        return res;
    }
};

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;
}

Top Sort

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

有向图的拓扑排序

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

请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1

若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x, y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列

输入格式

第一行包含两个整数 n 和 m
接下来 m 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x, y)

输出格式

共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可
否则输出 −1

数据范围

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

输入样例

输出样例

1 2 3

分析

邻接表的构建：
- h[N]：存储每个节点的邻接表头
- e[N]：存储邻接节点的目标节点
- ne[N]：存储邻接表中链表的下一个节点
- idx：记录当前边的编号
add(a, b)：将一条从节点 a 到节点 b 的边加入邻接表
topsort()：
- 使用队列 q 来存储入度为零的节点，初始化时将所有入度为零的节点加入队列
- 在 BFS 遍历过程中，若某个节点的入度减为零，则将其加入队列
- 最终，如果排序成功且队列中处理的节点数为 n，则说明拓扑排序存在，否则返回 false

时间复杂度

队列中的每个节点会被入队和出队一次，最多访问 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], d[N];  // 队列和入度数组
int n, m;  // 节点数和边数

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

// 拓扑排序算法
bool topsort()
{
  int hh = 0, tt = -1;

  // 将所有入度为 0 的节点加入队列
  for (int i = 1; i <= n; ++i)
    if (d[i] == 0)
      q[++tt] = i;

  // 进行拓扑排序
  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] == 0)  // 如果该节点的入度减为 0，则加入队列
        q[++tt] = j;
    }
  }

  // 如果队列中的节点数等于总节点数，说明拓扑排序成功
  return tt == n - 1;
}

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

  std::cin >> n >> m;  // 输入节点数和边数
  for (int i = 0; i < m; ++i)
  {
    int x, y;
    std::cin >> x >> y;  // 输入每条边
    add(x, y);  // 将边加入邻接表
    ++d[y];  // 更新节点 y 的入度
  }

  if (topsort())  // 如果拓扑排序成功
  {
    for (int i = 0; i < n; ++i)  // 输出拓扑排序
      std::cout << q[i] << ' ';
    std::cout << '\n';
  }
  else
    std::cout << -1 << '\n';  // 如果无法进行拓扑排序，输出 -1

  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;
}

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;
}

Sort An Array

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

912. 排序数组

分析

选取基准：选择当前区间的第一个元素 nums[l] 作为基准 x
双指针划分：
- 使用 i 从左向右找大于等于 x 的元素
- 使用 j 从右向左找小于等于 x 的元素
- 交换 nums[i] 和 nums[j]，直到 i >= j，此时 j 是分界点
递归排序：
- 递归地对 [l, j] 和 [j + 1, r] 两部分继续快速排序，直到 l >= r

时间复杂度

时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(logn)

C++代码

/***        quick sort      ***/
class Solution
{
public:
    // 快速排序函数
    void quick_sort(std::vector<int>& nums, int l, int r)
    {
        if (l >= r) // 递归终止条件
            return;

        int x = nums[l], i = l - 1, j = r + 1;

        // 双指针划分
        while (i < j)
        {
            do ++i; while (nums[i] < x); // 找到大于等于 x 的元素
            do --j; while (nums[j] > x); // 找到小于等于 x 的元素
            if (i < j)
                std::swap(nums[i], nums[j]); // 交换不符合位置的元素
        }

        quick_sort(nums, l, j);   // 递归处理左半部分
        quick_sort(nums, j + 1, r); // 递归处理右半部分
    }

    vector<int> sortArray(vector<int>& nums)
    {
        quick_sort(nums, 0, nums.size() - 1);
        return nums;
    }
};

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;
}

Sum of All Odd Length Subarrays

Tue, 11 Mar 2025 00:00:00 +0000

1588. 所有奇数长度子数组的和

分析

枚举起点 i 和终点 j，累积和

双重循环遍历 arr，枚举所有可能的子数组起点 i 和终点 j
维护 sum 变量，计算 arr[i] ~ arr[j] 的子数组和：
- 每次 j 递增，就加上 arr[j]
- 如果 j - i + 1 是奇数，说明当前 sum 是一个奇数长度子数组和，就将当前 sum 累加到 res 里

时间复杂度

时间复杂度 O(n^2)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int sumOddLengthSubarrays(vector<int>& arr)
    {
        int res = 0;
        for (int i = 0; i < arr.size(); ++i)  // 遍历子数组的起点 i
        {
            int sum = 0;
            for (int j = i; j < arr.size(); ++j) // 遍历子数组的终点 j
            {
                sum += arr[j]; // 计算子数组和
                if ((j - i + 1) % 2 == 1) // 仅当长度为奇数时才累加
                    res += sum;
            }
        }
        return res;
    }
};

Intersection of Two Arrays II

Sun, 02 Mar 2025 00:00:00 +0000

350. 两个数组的交集II

分析

由于交集的每个元素的出现次数需要和两个数组中的最小出现次数一致，因此需要一个数据结构来存储 nums1 中每个元素的个数
由于 std::unordered_multiset 允许存储重复元素，所以可以用它来存储 nums1 的所有元素
遍历 nums2，检查当前元素是否在 unordered_multiset 中，如果存在，则加入结果数组，并从 unordered_multiset 中删除该元素，以确保每个元素只被匹配一次

时间复杂度

时间复杂度 O(n + m)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2)
    {
        std::vector<int> res;
        std::unordered_multiset<int> hash;

        // 1. 统计 nums1 的元素频次
        for (int x : nums1)
            hash.insert(x);

        // 2. 遍历 nums2，检查是否在 hash 中
        for (int x : nums2)
            if (hash.count(x))  // 如果 x 在 hash 中
            {
                res.push_back(x);  // 加入结果数组
                hash.erase(hash.find(x));  // 删除 hash 中的一个 x（防止重复计数）
            }

        return res;
    }
};

Intersection of Two Arrays

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

349. 两个数组的交集

分析

将 nums1 中的元素插入到哈希集合中
遍历 nums2，对于每一个元素，如果该元素在哈希集合中存在，就表示它是 nums1 和 nums2 的交集中的元素
每次发现交集元素时，将其添加到结果数组 res 中，并从哈希集合中删除该元素，以保证结果中不包含重复元素

时间复杂度

时间复杂度 O(n + m)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
    {
        std::unordered_set<int> hash;  // 用于存储 nums1 中的元素
        std::vector<int> res;           // 用于存储交集的结果

        // 将 nums1 中的所有元素插入到哈希集合中
        for (int x : nums1)
            hash.insert(x);

        // 遍历 nums2，如果元素存在于哈希集合中，则表示是交集的一部分
        for (int x : nums2)
            if (hash.count(x))  // 查找 x 是否在哈希集合中
            {
                res.push_back(x);  // 将交集元素添加到结果中
                hash.erase(x);     // 删除该元素，避免重复添加
            }

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

IPO

Tue, 25 Feb 2025 00:00:00 +0000

502.IPO

分析

项目排序
- 将每个项目的启动资本和利润配对，并按照启动资本排序
动态选择
- 将当前资本 w 可以启动的所有项目的利润放入最大堆
- 从堆中选择一个利润最大的项目并完成，更新当前资本
退出条件
- 如果没有可以选择的项目（即堆为空），或者已经完成了 k 个项目，就可以退出

时间复杂度

排序项目数组：O(nlogn)
每次操作通过堆插入或弹出元素，最多需要 O(logn) 时间，因此 k 次操作的复杂度是 O(klogn)

总时间复杂度 O(nlogn)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int findMaximizedCapital(int k, int w, vector<int>& profits, vector<int>& capital)
    {
        int n = profits.size();
        std::vector<std::pair<int, int>> projects;

        // 将项目的启动资本和利润配对，并按启动资本排序
        for (int i = 0; i < n; ++i)
            projects.push_back({capital[i], profits[i]});
        std::sort(projects.begin(), projects.end());

        // 最大堆，用来存放前资本 w 可以启动的所有项目的利润
        std::priority_queue<int> heap;
        int i = 0;

        // 完成最多 k 个项目
        while (k--)
        {
            // 将所有可以启动的项目的利润加入堆
            while (i < n && projects[i].first <= w)
                heap.push(projects[i++].second);

            // 如果堆为空，表示没有可用的项目，退出
            if (heap.empty())
                break;

            // 从堆中选择利润最大的项目并完成
            w += heap.top();
            heap.pop();
        }

        return w;
    }
};

Maximal Square

Mon, 24 Feb 2025 00:00:00 +0000

221. 最大正方形

分析

初始化：
- n 和 m 分别为矩阵的行数和列数。
- 状态表示：f[i][j] 表示以 matrix[i-1][j-1] 为右下角的最大正方形的边长
状态转移：
- 对于每一个 matrix[i - 1][j - 1] == '1'，我们通过状态转移方程更新 f[i][j] 的值
- f[i][j] 的值是通过左边、上边和左上角的最小值加 1 来计算的，表示我们可以扩展一个更大的正方形：f[i][j] = min(f[i-1][j], f[i][j-1], f[i-1][j-1]) + 1
更新最大边长：
- 每次更新 f[i][j] 时，比较当前 f[i][j] 的值是否大于当前最大边长 res，如果大于，则更新 res
返回结果：
- 最终返回的结果是 res * res，即最大正方形的面积

时间复杂度

时间复杂度 O(n * m)

空间复杂度

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

C++代码

class Solution
{
public:
    int maximalSquare(vector<vector<char>>& matrix)
    {
        // 判断输入矩阵是否为空
        if (matrix.empty() || matrix[0].empty())
            return 0;

        int n = matrix.size(), m = matrix[0].size();

        // 初始化状态表示 f，大小为 (n+1) * (m+1)
        std::vector<std::vector<int>> f(n + 1, std::vector<int>(m + 1));
        int res = 0;  // 存储最大正方形的边长

        // 遍历矩阵每个元素
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= m; ++j)
                if (matrix[i - 1][j - 1] == '1')  // 如果当前位置是 '1'
                {
                    // 更新 f[i][j] 为左边、上边和左上角最小值加 1
                    f[i][j] = std::min(f[i - 1][j], std::min(f[i][j - 1], f[i - 1][j - 1])) + 1;
                    // 更新最大正方形边长
                    res = std::max(res, f[i][j]);
                }

        // 返回最大正方形的面积
        return res * res;
    }
};

Best Time to Buy and Sell Stock IV

Sun, 23 Feb 2025 00:00:00 +0000

188. 买卖股票的最佳时机IV

分析

无交易限制的情况：
- 当 k >= n / 2（即可以无限次交易的情况），那么我们可以通过每次只要当前价格比前一天高就进行交易，获取利润
- 这种情况下，我们只需要遍历数组，当 prices[i] < prices[i + 1] 时，进行买卖，利润就会累加
有交易次数限制的情况：
- 当 k < n / 2 时，我们需要考虑最多进行 k 次交易的情况。为此，我们需要使用动态规划来计算不同交易次数的最大利润
- 使用动态规划状态 f[i][j] 表示前 i 天内进行 j 次交易的最大利润。我们还可以使用辅助数组 g[i][j] 来记录前 i 天内进行 j-1 次交易，买入股票时的状态（即股票买入价格的最优状态）
- 每次更新 f[i][j] 和 g[i][j] 时，考虑的是：
  - 卖出：通过 g[i-1][j] + prices[i-1] 来记录前 i-1 天完成 j 次交易的最大利润加上当前价格（即卖出）
  - 买入：通过 f[i-1][j-1] - prices[i-1] 来记录前 i-1 天完成 j-1 次交易的最大利润减去当前价格（即买入）
状态转移方程
- f[i][j] = max(f[i-1][j], g[i-1][j] + prices[i-1])：卖出时，选择前 i-1 天进行 j 次交易的最大利润，再加上今天卖出的利润
- g[i][j] = max(g[i-1][j], f[i-1][j-1] - prices[i-1])：买入时，选择前 i-1 天进行 j-1 次交易的最大利润，再减去今天买入的价格

时间复杂度

时间复杂度 O(k * n)

空间复杂度

空间复杂度为 O(k * n)

C++代码

class Solution
{
public:
    int maxProfit(int k, vector<int>& prices)
    {
        int res = 0;
        int n = prices.size();

        // 交易次数 k 大于等于 n / 2，则可以进行无限次交易
        if (k >= n / 2)
        {
            for (int i = 0; i < n - 1; ++i)
                if (prices[i] < prices[i + 1])
                    res += prices[i + 1] - prices[i];  // 贪心：只要后一天价格高于前一天就交易
            return res;
        }

        int INF = 0x3f3f3f3f;
        vector<vector<int>> f(n + 1, vector<int>(k + 1, -INF));  // 动态规划数组，初始化为一个大负值
        vector<vector<int>> g = f;  // 辅助数组，用于存储买入操作时的状态

        f[0][0] = 0;  // 在第 0 天，不进行任何交易，利润为 0

        // 遍历每一天
        for (int i = 1; i <= n; ++i)
            for (int j = 0; j <= k; ++j)
            {
                // 若不做交易，利润保持不变。若交易，进行卖出操作
                f[i][j] = max(f[i - 1][j], g[i - 1][j] + prices[i - 1]);

                g[i][j] = g[i - 1][j];  // 不进行买入操作

                if (j)  // 如果可以进行交易
                    g[i][j] = max(g[i][j], f[i - 1][j - 1] - prices[i - 1]);  // 进行买入操作

                res = max(res, f[i][j]);  // 更新最大利润
            }

        return res;  // 返回最终的最大利润
    }
};

Best Time to Buy and Sell Stock III

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

123. 买卖股票的最佳时机III

分析

为了计算出最大利润，可以将问题拆解成两个阶段：

第一笔交易：计算在前几天内，买入并卖出获得的最大利润
第二笔交易：计算在后几天内，买入并卖出获得的最大利润，并与第一笔交易的最大利润结合

第一次交易：
- 初始化一个数组 f，用来记录前 i 天结束时的最大利润
- 变量 minp 用来记录前 i 天中的最低股价。在每一天，计算当前股价和 minp 的差值，更新 f[i] 为当前的最大利润
第二次交易：
- 在完成第一次交易后，我们从后往前遍历 prices 数组，计算从第 i 天开始的最大卖出利润 maxp - prices[i-1]，然后将其与 f[i-1]（表示前 i-1 天的最大利润）合并得到总利润
最终结果：
- res 记录的是两次交易合并的最大利润

时间复杂度

时间复杂度 O(n)，遍历 prices 数组两次

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        int n = prices.size();

        // f[i] 表示前 i 天结束时的最大利润
        std::vector<int> f(n + 1);

        // 计算第一次交易的最大利润
        for (int i = 1, minp = INT_MAX; i <= n; ++i)
        {
            f[i] = std::max(f[i - 1], prices[i - 1] - minp);  // max(不交易, 卖出利润)
            minp = std::min(minp, prices[i - 1]);  // 更新最小买入价格
        }

        int res = 0;

        // 计算第二次交易的最大利润
        for (int i = n, maxp = 0; i > 0; --i)
        {
            // 计算第二次交易和第一次交易合并的最大利润
            res = std::max(res, maxp - prices[i - 1] + f[i - 1]);
            maxp = std::max(maxp, prices[i - 1]);  // 更新最大卖出价格
        }

        return res;
    }
};

Interleaving String

Fri, 21 Feb 2025 00:00:00 +0000

97. 交错字符串

分析

初始化：
- 先计算 s1 和 s2 的长度 n 和 m，并检查 s3 的长度是否为 n + m。如果不是，直接返回 false
- 为了方便处理边界情况，我们给 s1、s2 和 s3 的开头加上一个空格 ' '，这样可以简化状态转移的边界处理
状态表示 f：
- f[i][j] 表示由 s1 的前 i 个字符和 s2 的前 j 个字符是否能交错组成 s3 的前 i + j 个字符。
- 初始化 f[0][0] = true，表示空的 s1 和空的 s2 能交错组成空的 s3
动态规划转移：
- 对于每一个 i 和 j，检查当前字符是否匹配：
- 如果 s1[i] 和 s3[i + j] 相等，则可以从 f[i-1][j] 更新到 f[i][j]
- 如果 s2[j] 和 s3[i + j] 相等，则可以从 f[i][j-1] 更新到 f[i][j]
结果返回：
- 最终返回 f[n][m]，即判断 s1 和 s2 是否能够交错组成 s3

时间复杂度

时间复杂度 O(n * m)，其中 n 是 s1 的长度，m 是 s2 的长度

空间复杂度

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

C++代码

class Solution
{
public:
    bool isInterleave(string s1, string s2, string s3)
    {
        int n = s1.size(), m = s2.size();

        // 如果 s3 的长度不等于 s1 和 s2 的长度之和，直接返回 false
        if (s3.size() != n + m)
            return false;

        // 加上空字符方便处理边界情况
        s1 = ' ' + s1;
        s2 = ' ' + s2;
        s3 = ' ' + s3;

        // 初始化状态表示f
        std::vector<std::vector<bool>> f(n + 1, std::vector<bool>(m + 1));

        // 状态转移
        for (int i = 0; i <= n; ++i)
        {
            for (int j = 0; j <= m; ++j)
            {
                if (i == 0 && j == 0)
                    // 起始点，空的 s1 和 s2 可以交错组成空的 s3
                    f[i][j] = true;
                else
                {
                    // 如果 s1[i] == s3[i + j]，则可以从 f[i-1][j] 更新到 f[i][j]
                    if (i && s1[i] == s3[i + j])
                        f[i][j] = f[i - 1][j];
                    // 如果 s2[j] == s3[i + j]，则可以从 f[i][j-1] 更新到 f[i][j]
                    if (j && s2[j] == s3[i + j])
                        f[i][j] = f[i][j] || f[i][j - 1];
                }
            }
        }

        // 返回结果
        return f[n][m];
    }
};

Unique Paths II

Thu, 20 Feb 2025 00:00:00 +0000

63. 不同路径II

分析

状态定义：f[i][j] 代表从起点 (0, 0) 到达 (i, j) 的路径数
状态转移：
- 如果 obstacleGrid[i][j] == 0，表示当前位置可以走（没有障碍物），我们根据递推公式更新路径数：
  - 如果当前位置是起点 (0, 0)，则 f[0][0] = 1
  - 否则，当前位置的路径数由上方和左方的路径数之和 f[i][j] = f[i-1][j] + f[i][j-1] 得出
- 如果 obstacleGrid[i][j] == 1，说明当前位置有障碍物，不能走到这里，无需处理 f[i][j]，因为初始的 f[i][j] 值为 0
返回最终结果：循环结束后，f[n-1][m-1] 就是从起点到终点的不同路径数

时间复杂度

时间复杂度 O(n * m)

空间复杂度

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

C++代码

class Solution
{
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid)
    {
        int n = obstacleGrid.size(), m = obstacleGrid[0].size();
        // 初始化 DP 数组
        std::vector<std::vector<int>> f(n, std::vector<int>(m));

        // 遍历每个格子
        for (int i = 0; i < n; ++ i)
            for (int j = 0; j < m; ++ j)
                if (obstacleGrid[i][j] == 0)  // 如果当前格子没有障碍物
                {
                    if (i == 0 && j == 0)  // 起始位置
                        f[i][j] = 1;  // 从起点出发，路径数为 1
                    else
                    {
                        if (i)  // 如果不在第一行
                            f[i][j] += f[i - 1][j];  // 从上方格子来的路径数
                        if (j)  // 如果不在第一列
                            f[i][j] += f[i][j - 1];  // 从左方格子来的路径数
                    }
                }

        return f[n - 1][m - 1];  // 返回右下角的路径数
    }
};

Triangle

Wed, 19 Feb 2025 00:00:00 +0000

120. 三角形最小路径和

分析

状态定义：triangle[i][j] 表示从底层到第i行j列节点的最小路径和
状态转移：triangle[i][j] 的值等于下一层相邻节点中的较小值 + 当前节点值: triangle[i][j] += std::min(triangle[i + 1][j], triangle[i + 1][j + 1])
最终，triangle[0][0] 中存储的就是从底端到顶端的最小路径和

时间复杂度

时间复杂度 O(n^2)，其中 n 是三角形的行数。每一行最多有 n 个元素，处理每个元素时需要计算两个相邻节点的最小值

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int minimumTotal(vector<vector<int>>& triangle)
    {
        // 从倒数第二行开始，向上更新最小路径和
        for (int i = triangle.size() - 2; i >= 0; --i)
            for (int j = 0; j < triangle[i].size(); ++j)  // 遍历每一行的元素
                triangle[i][j] += std::min(triangle[i + 1][j], triangle[i + 1][j + 1]);  // 更新当前点的最小路径和
        return triangle[0][0];  // 返回到达顶点的最小路径和
    }
};

Max Points On A Line

Tue, 18 Feb 2025 00:00:00 +0000

149. 直线上最多的点数

分析

哈希表：通过哈希表来记录每个斜率出现的频次。对于每个点，遍历其他点，计算斜率，并更新哈希表。如果多个点具有相同的斜率，则它们在同一条直线上
特殊情况：需要考虑以下几种情况：
- 重复点：如果两个点重合，它们的斜率是相同的
- 竖直线：当 dx = 0 时，说明是竖直线，斜率可以用一个特殊值（如无穷大）表示
最终结果：对于每个点，计算该点与其他点的最大共线点数，并维护一个最大值

时间复杂度

时间复杂度 O(n^2)，其中 n 是点的数量。对于每个点 p，我们遍历所有其他点 q，计算它们的斜率

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxPoints(vector<vector<int>>& points)
    {
        int res = 0;
        for (std::vector<int>& p : points)
        {
            int same = 0, vertical = 0;
            std::unordered_map<long double, int> count;
            for (std::vector<int>& q : points)
            {
                if (p == q)  // 统计重叠点的个数
                    ++same;
                else if (p[0] == q[0])  // x坐标相同，统计竖直线上点的个数
                    ++vertical;
                else
                {
                    long double slope = (long double)(q[1] - p[1]) / (q[0] - p[0]);  // 计算斜率
                    ++count[slope];  // 记录相同斜率的点数
                }
            }

            // 找到最大斜率的点数（加上重叠点数）
            for (auto [slope, cnt] : count)
                res = std::max(res, same + cnt);

            // 比较竖直线的点数（加上重叠点数）和最大斜率的点数
            res = std::max(res, same + vertical);
        }
        return res;
    }
};

Pow X N

Mon, 17 Feb 2025 00:00:00 +0000

50. Pow(x, n)

分析

长整型 LL 定义：long long 类型用于处理 n = INT_MIN 的情况，因为 abs(INT_MIN) 会溢出 int 类型
判断 n 是否为负数：如果 n 是负数，最后需要返回 1 / res
快速幂的实现：通过右移 k（即 k >>= 1）将 n 每次除以 2，并根据 k 是否为奇数来决定是否将当前的 x 乘到结果中
计算 x^n：
- 如果 k 的最低位是 1（即 k & 1），则当前的 x 需要乘到结果中
- 每次将 x 平方，即 x = x * x，这相当于将指数减少了一半
负指数情况：如果 n 是负数，返回 1 / res，否则返回计算结果 res

时间复杂度

时间复杂度 O(logn)，每次将 n 减半，通过二进制方式快速计算

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    double myPow(double x, int n)
    {
        using LL = long long;  // 使用 long long 类型来处理 n = INT_MIN 的特殊情况
        bool is_minus = (n < 0);  // 判断 n 是否为负数
        double res = 1;

        // 使用绝对值的 n 进行计算，避免负数的影响
        for (LL k = std::abs(LL(n)); k; k >>= 1)  // 快速幂算法：k 是二进制表示
        {
            if (k & 1)  // 如果 k 的最低位是 1
                res *= x;  // 将当前的 x 乘到结果上
            x *= x;  // x 自身平方
        }

        if (is_minus)  // 如果 n 是负数，返回 1 / res
            return 1 / res;
        return res;
    }
};

Sort

Mon, 17 Feb 2025 00:00:00 +0000

排序

#include <iostream>
#include <algorithm>
#include <vector>

void quick_sort(std::vector<int>& nums, int l, int r);
void merge_sort(std::vector<int>& nums, int l, int r);
void select_sort(std::vector<int>& nums);
void insert_sort(std::vector<int>& nums);
void binary_sort(std::vector<int>& nums);
void bubble_sort(std::vector<int>& nums);

int main()
{
  int n;
  scanf("%d", &n);

  std::vector<int> nums(n);
  for (int i = 0; i < n; ++ i)
    scanf("%d", &nums[i]);

  quick_sort(nums, 0, n - 1);
  merge_sort(nums, 0, n - 1);
  select_sort(nums);
  insert_sort(nums);
  binary_sort(nums);
  bubble_sort(nums);

  for (int i = 0; i < n; ++ i)
    printf("%d ", nums[i]);

  return 0;
}

快速排序

选取基准值（pivot）：x = nums[(l + r) >> 1]
双指针划分数组：
- i 从左往右，找到第一个 ≥ pivot 的数
- j 从右往左，找到第一个 ≤ pivot 的数
- 交换 nums[i] 和 nums[j]，直到 i >= j
递归处理左右子数组：
- 递归排序 [l, j]（左半部分）
- 递归排序 [j+1, r]（右半部分）

复杂度

时间复杂度
- 最佳情况（每次都均匀划分）：O(nlogn)
- 平均情况（随机数据）：O(nlogn)
- 最坏情况（已排序数组，划分极端不均匀）：O(n²)
空间复杂度
- 最坏情况（单侧划分，递归深度 O(n))）：O(n)
- 平均情况（均匀划分，递归深度 O(logn))）：O(logn)

void quick_sort(std::vector<int>& nums, int l, int r)
{
  if (l >= r) return;  // 递归终止条件

  int i = l - 1, j = r + 1, x = nums[(l + r) >> 1]; // 取中间值作为基准
  while (i < j)
  {
    do ++i; while (nums[i] < x); // 找到左侧大于等于 pivot 的元素
    do --j; while (nums[j] > x); // 找到右侧小于等于 pivot 的元素
    if (i < j)
      std::swap(nums[i], nums[j]); // 交换不符合条件的元素
  }

  quick_sort(nums, l, j);   // 递归排序左半部分
  quick_sort(nums, j + 1, r); // 递归排序右半部分
}

归并排序

递归地将数组划分为左右两部分：
- 直到子数组长度为 1，即 l >= r，终止递归
分别对左右两部分进行排序：
- 递归调用 merge_sort(nums, l, mid)
- 递归调用 merge_sort(nums, mid + 1, r)
合并两个有序数组：
- 使用双指针方法合并 nums[l ~ mid] 和 nums[mid+1 ~ r]
- 额外使用一个 tmp 数组存储排序后的结果，再复制回 nums

复杂度

时间复杂度
- 每次划分数组需要 O(logn) 次递归
- 每次合并两个有序数组需要 O(n) 时间
- 总时间复杂度：O(nlogn)
空间复杂度
- 需要额外 O(n) 的辅助数组 tmp 存储合并结果
- 总空间复杂度：O(n)

void merge_sort(std::vector<int>& nums, int l, int r)
{
  if (l >= r) return;  // 递归终止条件：子数组长度为1

  int mid = (l + r) >> 1;  // 取中间点
  merge_sort(nums, l, mid);  // 递归排序左半部分
  merge_sort(nums, mid + 1, r);  // 递归排序右半部分

  std::vector<int> tmp(nums.size());  // 临时数组用于合并
  int i = l, j = mid + 1, k = 0;  // i 遍历左半部分，j 遍历右半部分

  // 归并两个有序子数组
  while (i <= mid && j <= r)
  {
    if (nums[i] <= nums[j])
      tmp[k++] = nums[i++];  // 选较小的数加入临时数组
    else
      tmp[k++] = nums[j++];
  }

  // 处理剩余元素
  while (i <= mid) tmp[k++] = nums[i++];
  while (j <= r) tmp[k++] = nums[j++];

  // 复制回原数组
  for (int i = l, k = 0; i <= r; ++i, ++k)
    nums[i] = tmp[k];
}

堆排序

建堆：从最后一个非叶子节点 n/2 开始自上而下堆化 down()
- 建立大根堆：
  - 满足大根堆的性质：父节点大于等于子节点
- 建立小根堆：
  - 满足小根堆的性质：父节点小于等于子节点
排序：
- 交换堆顶元素（最大值/最小值）和堆尾元素，然后调整剩余元素继续保持大根堆/小根堆
- 每次取出堆顶元素，最终形成升序/降序排列

复杂度

时间复杂度
- 建堆：O(n)
- 排序调整堆：每次 down() 需要 O(log n)，执行 n 次，总计 O(nlogn)
- 总时间复杂度：O(nlogn)
空间复杂度
- 堆排序在原数组上进行排序，没有额外的数组存储，空间复杂度 O(1)

#include <iostream>
#include <algorithm>
#include <vector>

// 维护小根堆性质 (较大值向下调整)
void big_down(std::vector<int>& nums, int u, int sz)
{
    int t = u;
    if (u * 2 <= sz && nums[t] > nums[u * 2])  // 左子节点较小
        t = u * 2;
    if (u * 2 + 1 <= sz && nums[t] > nums[u * 2 + 1])  // 右子节点较小
        t = u * 2 + 1;

    if (t != u)  // 需要交换
    {
        std::swap(nums[t], nums[u]);
        big_down(nums, t, sz);  // 递归调整
    }
}

// 维护大根堆性质 (较小值向下调整)
void small_down(std::vector<int>& nums, int u, int sz)
{
    int t = u;
    if (u * 2 <= sz && nums[t] < nums[u * 2])  // 左子节点较大
        t = u * 2;
    if (u * 2 + 1 <= sz && nums[t] < nums[u * 2 + 1])  // 右子节点较大
        t = u * 2 + 1;

    if (t != u)  // 需要交换
    {
        std::swap(nums[t], nums[u]);
        small_down(nums, t, sz);  // 递归调整
    }
}

int main()
{
    int n;
    scanf("%d", &n);

    // 下标从1开始存储堆，避免叶子结点边界处理
    std::vector<int> nums(n + 1);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d", &nums[i]);
    }

    // 建堆 (从最后一个非叶子节点开始)
    for (int i = n / 2; i >= 1; --i)
    {
        big_down(nums, i, n);
    }

    int sz = n;
    // 堆排序
    for (int i = 0; i < n; ++i)
    {
        printf("%d ", nums[1]);  // 输出堆顶元素
        std::swap(nums[1], nums[sz]);  // 交换堆顶和堆尾元素
        -- sz;  // 缩小堆的范围
        big_down(nums, 1, sz);  // 重新调整堆
    }
    printf("\n");

    return 0;
}

选择排序

在第 i 轮中，从 i 到 n - 1 中选择最小值，并将其与 i 位置交换
进行 n - 1 轮排序后，数组有序

复杂度

时间复杂度 O(n^2)
空间复杂度 O(1)

void select_sort(std::vector<int>& nums)
{
  for (int i = 0; i < nums.size() - 1; ++i)
  {
    int min_idx = i;  // 记录当前最小值的索引
    for (int j = i + 1; j < nums.size(); ++j)
      if (nums[min_idx] > nums[j])  // 找到更小的元素
        min_idx = j;

    std::swap(nums[i], nums[min_idx]);  // 交换当前元素与最小值
  }
}

插入排序

从第二个元素开始，假设第一个元素已经是有序的
比较当前元素与已排序部分的元素，找到合适的插入位置
将当前元素插入到合适的位置，并调整数组中元素的位置

复杂度

时间复杂度
- 最佳情况（数组已经有序）：O(n)
  - 只需进行一次比较即可，每个元素都只需插入一次
- 最坏情况（数组逆序）：O(n^2)
  - 每次插入时需要将前面的所有元素都移动一遍
- 平均时间复杂度：O(n^2)
空间复杂度
- 空间复杂度：O(1)，插入排序是原地排序，无需额外空间

void insert_sort(std::vector<int>& nums)
{
  for (int i = 1; i < nums.size(); ++ i)  // 从第二个元素开始
  {
    int x = nums[i], j = i;  // 保存当前元素并从当前位置开始向前检查
    while (j >= 1 && x < nums[j - 1])  // 查找插入位置
    {
      nums[j] = nums[j - 1];  // 向右移动元素
      -- j;  // 移动索引
    }
    nums[j] = x;  // 插入当前元素
  }
}

折半插入排序

从第二个元素开始，假设第一个元素已经是有序的
使用二分查找在已排序部分找到插入的位置
将当前位置之后的元素向后移动一位，并将当前元素插入到找到的位置

复杂度

时间复杂度
- 最佳情况（数组已经有序）：O(n)
  - 每次只需进行一次比较即可，每个元素都只需插入一次
- 最坏情况（数组逆序）：O(n^2)
  - 二分查找将时间复杂度降低为 O(logn)，但每次插入仍然需要将元素移动，整体仍为 O(n^2)
- 平均时间复杂度：O(n^2)
空间复杂度
- 空间复杂度：O(1)，原地排序，不需要额外的空间

void binary_sort(std::vector<int>& nums)
{
  for (int i = 1; i < nums.size(); ++ i)  // 从第二个元素开始
  {
    if (nums[i - 1] < nums[i])  // 如果当前元素比前一个元素大，则跳过
      continue;

    int x = nums[i];  // 保存当前元素
    int l = 0, r = i - 1;  // 设置二分查找的左右边界

    while (l < r)  // 二分查找插入位置
    {
      int mid = (l + r) >> 1;
      if (x < nums[mid])
        r = mid;  // 当前元素小于mid，右边界左移
      else
        l = mid + 1;  // 当前元素大于mid，左边界右移
    }

    for (int j = i - 1; j >= r; -- j)  // 移动元素
      nums[j + 1] = nums[j];
    nums[r] = x;  // 插入当前元素到正确的位置
  }
}

冒泡排序

冒泡排序主要通过重复交换相邻的元素来将较小的元素冒泡到数组的前端，较大的元素则被“推”到数组的末端

比较相邻元素：从数组的第一个元素开始，逐一比较相邻的两个元素。如果它们的顺序不正确（即前一个元素大于后一个元素），则交换它们的位置
冒泡操作：经过一轮遍历后，最小的元素被冒泡到数组的前端
重复遍历：继续对剩余部分进行相同的操作，直到整个数组排序完成
提前终止：如果某一轮遍历中没有发生交换，说明数组已经是有序的，可以提前终止排序

复杂度

时间复杂度分析
- 最坏时间复杂度：O(n^2)，即当数组完全逆序时，每一轮都需要交换，每一对相邻元素都会进行比较和交换
- 最佳时间复杂度：O(n)，即当数组已经是有序时，只需进行一次遍历，不需要交换
- 平均时间复杂度：O(n^2)，适用于随机排列的数组
空间复杂度
- 空间复杂度：O(1)，原地排序，不需要额外的存储空间

void bubble_sort(std::vector<int>& nums)
{
  for (int i = 0; i < nums.size() - 1; ++ i) // 外层循环控制排序的轮数
  {
    bool is_swap = false; // 用于检查是否发生交换
    for (int j = nums.size() - 1; j > i; -- j) // 内层循环进行元素的比较与交换
    {
      if (nums[j] < nums[j - 1]) // 如果前一个元素大于后一个元素
      {
        std::swap(nums[j], nums[j - 1]); // 交换元素
        is_swap = true; // 标记发生了交换
      }
    }

    if (!is_swap) // 如果没有发生交换，说明数组已经有序，可以提前结束
      break;
  }
}

Sqrt X

Sun, 16 Feb 2025 00:00:00 +0000

69. x的平方根

分析

初始化：设定左右边界 l = 0 和 r = x，表示搜索区间
二分查找：
- 通过 (l + 1ll + r) >> 1 计算中间值 mid。这里使用了 1ll 来确保计算过程中不会发生整数溢出
- 判断 mid * mid <= x，如果成立，说明平方根的整数部分不大于 mid，我们将搜索区间的左边界 l 移动到 mid
- 如果 mid * mid > x，说明平方根在 mid 左边，更新右边界 r 为 mid - 1
终止条件：当 l == r 时，搜索结束，r 即为 x 的整数平方根

时间复杂度

总时间复杂度 O(logx)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int mySqrt(int x)
    {
      int l = 0, r = x;  // 设置搜索区间 [0, x]

      while (l < r)
      {
        int mid = (l + 1ll + r) >> 1;  // 计算中间值 mid，避免整数溢出
        if (mid <= x / mid)  // 如果 mid 的平方小于等于 x，则 mid 可能是答案
          l = mid;  // 如果 mid 满足条件，调整左边界为 mid
        else
          r = mid - 1;  // 如果 mid 不满足条件，调整右边界为 mid-1
      }

      return r;  // 返回最终的结果，r 为整数平方根
    }
};

Factorial Trail Zeroes

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

172. 阶乘后的零

分析

尾随零的产生是因为 10 = 2 * 5，每次有一个因数 2 和 5 的乘积，都会形成一个 10，从而在阶乘结果的末尾增加一个零

由于阶乘的数值中，因数 2 的出现频率远高于因数 5，所以我们只需要考虑 5 出现的次数，计算 n! 中 5 的因数的个数，即可得到尾随零的个数

计算 n! 中因数 5 的个数
对于 n 中所有能被 5 整除的数，每个数都至少包含一个 5，例如：5, 10, 15, 20...
如果一个数能被 25 整除，则它会包含额外的一个因数 5，比如 25 会有两个因数 5，50 也会有两个因数 5，依此类推
因此，n! 中尾随零的数量就是 n / 5 + n / 25 + n / 125 + ...，直到 5^k > n

时间复杂度

时间复杂度：O(log_5 n) ，因为每次将 n 除以 5，直到 n 小于 5 为止

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int trailingZeroes(int n)
    {
      int res = 0;
      while (n)
      {
        res += n / 5;  // 计算能被 5 整除的数
        n /= 5;         // 除以 5，继续计算更高次方的 5
      }
      return res;
    }
};

Palindrome Number

Fri, 14 Feb 2025 00:00:00 +0000

9. 回文数

分析

负数一定不是回文数：
- 例如 -121 变成 121-，不对称，因此直接返回 false
将数字翻转后与原数比较：
- 反转 x 的每一位数字，存入 b，然后判断 b == x 是否成立

时间复杂度

时间复杂度与 x 的位数成正比，最多 10 次（int 最大 32 位）

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool isPalindrome(int x)
    {
      if (x < 0)  // 负数一定不是回文数
        return false;

      long a = x, b = 0;  // a 复制 x，b 存储翻转后的数
      while (a)
      {
        b = b * 10 + a % 10;  // 取出 a 的最后一位，加到 b 的末尾
        a /= 10;  // 去掉 a 的最后一位
      }

      return b == x;  // 判断反转后的 b 是否等于原数 x
    }
};

Plus One

Fri, 14 Feb 2025 00:00:00 +0000

66. 加一

分析

从低位到高位进行加法，考虑进位
如果所有位数都发生进位（如 999 -> 1000），需要在最高位补 1

时间复杂度

时间复杂度 O(n)，遍历数组两次（反转 + 加法）

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    vector<int> plusOne(vector<int>& digits)
    {
      std::reverse(digits.begin(), digits.end());  // 反转数组，使低位在前
      int t = 1;  // 初始进位值为 1，即加 1

      for (int& x: digits)
      {
        t += x;   // 当前位加上进位
        x = t % 10;  // 更新当前位
        t /= 10;  // 计算新的进位
      }

      if (t)  // 最高位还有进位
        digits.push_back(t);

      std::reverse(digits.begin(), digits.end());  // 还原数组顺序
      return digits;
    }
};

Bitwise and of Numbers Range

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

201. 数字范围按位与

分析

按位与的性质
- 任何数字与 0 进行按位与，结果都是 0，即 x & 0 = 0
- 相邻数字的按位与会减少 1 位的 1，例如：

计算 5 & 6 & 7 = 4，可以看到最右侧的 1 被清除了

观察区间变化
- 若 left 和 right 的二进制前缀相同，则它们的按位与结果保留这个前缀，后面的位全部补 0
- 若 left 和 right 的某一位出现了不同（即 0->1 或 1->0），则从该位及其更低位的按位与结果必然为 0

时间复杂度

由于整数的二进制表示最多 32 位，我们最多遍历 32 次，因此时间复杂度为 O(1)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int rangeBitwiseAnd(int left, int right)
    {
      int res = 0; // 存储最终结果
      for (int i = 30; i >= 0; -- i)  // 从高位到低位遍历每一位
      {
        if ((left >> i & 1) != (right >> i & 1))  // 如果某一位的 left 和 right 不同，终止循环
          break;
        if (left >> i & 1)  // 如果 left 在该位是 1，则保留该位
          res += (1 << i);
      }
      return res;
    }
};

Find K Pairs with Smallest Sums

Wed, 12 Feb 2025 00:00:00 +0000

373. 查找和最小的K对数字

分析

初始化最小堆：
- 初始时，最小堆可以由 nums1[0] 和 nums2[i]（i 从 0 到 m-1）组成，因为 nums1 和 nums2 都是有序的，最小的数对总是以 nums1[0] 开头与 nums2 的元素组合
- 每个堆元素包含一个三元组 [sum, i, j]，其中 sum 是当前数对的和，i 是 nums1 的索引，j 是 nums2 的索引
使用堆来不断提取和最小的数对：
- 每次从堆中取出和最小的数对，并将其加入结果集。
- 如果 nums1[i+1] 和 nums2[j] 存在，推入堆中新的数对 nums1[i+1] 和 nums2[j] 的组合
堆的操作：
- 每次都取出和最小的数对进行处理，直到得到 k 个数对

时间复杂度

初始化堆：将 nums2 中的每个元素与 nums1[0] 配对，复杂度为 O(mlogm)，其中 m 是 nums2 的大小
每次弹出和插入操作的时间复杂度为 O(logk)

总体时间复杂度为 O(klogk)，其中 k 是要求的数对个数

空间复杂度

空间复杂度为 O(k)

C++代码

class Solution
{
public:
    vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k)
    {
        std::vector<std::vector<int>> res;   // 存储结果
        int n = nums1.size(), m = nums2.size();
        if (n == 0 || m == 0)                // 如果数组为空，直接返回空结果
            return res;

        // 使用优先队列（最小堆）存储 (sum, i, j)
        std::priority_queue<std::vector<int>, std::vector<std::vector<int>>, std::greater<std::vector<int>>> heap;

        // 将 nums1[0] 与 nums2 中的每个元素配对，推入堆中
        for (int i = 0; i < m; ++i)
            heap.push({nums1[0] + nums2[i], 0, i});

        // 从堆中取出和最小的 k 对
        while (k-- && heap.size())
        {
            std::vector<int> t = heap.top();
            heap.pop();
            res.push_back({nums1[t[1]], nums2[t[2]]});  // 将结果加入 res

            // 如果 t[1]+1 < n，继续将 nums1[t[1]+1] 与 nums2[t[2]] 配对推入堆中
            if (t[1] + 1 < n)
                heap.push({nums1[t[1] + 1] + nums2[t[2]], t[1] + 1, t[2]});
        }
        return res;
    }
};

Single Number II

Tue, 11 Feb 2025 00:00:00 +0000

137. 只出现一次的数字II

分析

考虑整数在计算机中以 32 位二进制形式表示，可以逐位统计数组中每个位上的 1 的出现次数

逐位遍历
- 对于每一位 i（从 0 到 31 位），统计所有数字中第 i 位上的 1 的总数 c
模 3 运算
- 若某个位上的 1 的出现次数不是 3 的倍数，则说明这个位在目标数中为 1
- 将该位加入结果 res
结果构建
- 将每一位结果通过位运算 res |= (c % 3) << i 累加到最终结果 res 中

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int singleNumber(vector<int>& nums)
    {
        int res = 0;
        for (int i = 0; i < 32; ++i) // 遍历每一个二进制位
        {
            int c = 0;

            // 统计当前二进制位上 1 的数量
            for (int x : nums)
                c += (x >> i) & 1;

            // 若该二进制位的 1 数量不是 3 的倍数，将该位加入结果
            res |= (c % 3) << i;
        }
        return res;
    }
};

Add Binary

Mon, 10 Feb 2025 00:00:00 +0000

67. 二进制求和

分析

字符串逆序遍历
- 为了方便从最低位到最高位逐位相加，首先将 a 和 b 字符串进行反转
逐位相加
- 维护进位变量 t，依次对 a 和 b 的每一位进行相加：
  - 若当前索引在 a 范围内，则加上 a[i] - '0'
  - 若当前索引在 b 范围内，则加上 b[i] - '0'
  - 将当前位结果 t % 2 转为字符加入结果字符串 c
  - 更新进位 t /= 2
处理多余进位
- 当遍历完两个字符串后，若仍有进位，则继续加入结果字符串
结果反转
- 将结果字符串 c 反转回正序，即为最终答案

时间复杂度

时间复杂度 O(max(m, n))，其中 m 和 n 分别为字符串 a 和 b 的长度

空间复杂度

空间复杂度为 O(max(m, n))

C++代码

class Solution
{
public:
    string addBinary(string a, string b)
    {
        // 反转字符串以方便从低位开始计算
        std::reverse(a.begin(), a.end());
        std::reverse(b.begin(), b.end());

        std::string c;
        for (int i = 0, t = 0; i < a.size() || i < b.size() || t; ++i)
        {
            // 加上 a 和 b 当前位的数值
            if (i < a.size()) t += a[i] - '0';
            if (i < b.size()) t += b[i] - '0';

            // 当前位结果加入结果字符串
            c += t % 2 + '0';

            // 更新进位
            t /= 2;
        }

        // 反转回正序
        std::reverse(c.begin(), c.end());
        return c;
    }
};

Maximum Sum Circular Subarray

Sun, 09 Feb 2025 00:00:00 +0000

918. 环形子数组的最大和

分析

双倍扩展数组
- 为了处理环形数组，将 nums 扩展为两倍长度的数组 s（模拟拼接后的连续数组），便于通过滑动窗口寻找环形最大子数组
前缀和数组
- s[i] 表示从 nums[0] 到 nums[i % n] 的前缀和，通过前缀和计算任意区间的子数组和
滑动窗口 + 单调队列
- 维护一个单调递增的双端队列 q，存储前缀和的索引：
  - 队首：保证窗口长度不超过 n，且队首元素是当前窗口内的最小前缀和
    - 队尾：维护递增性质
动态更新结果
- 在每一步中计算 s[i] - s[q.front()]，更新最大子数组和

时间复杂度

总时间复杂度 O(n)，每个元素最多进出队列一次，遍历一遍即可得到结果

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxSubarraySumCircular(vector<int>& nums)
    {
        int n = nums.size();
        std::vector<int> s(n * 2);  // 扩展两倍长度的前缀和数组
        s[0] = nums[0];

        // 构建前缀和数组
        for (int i = 1; i < n * 2; ++i)
            s[i] = s[i - 1] + nums[i % n];

        std::deque<int> q;  // 单调队列存储前缀和的索引
        q.push_front(0);
        int res = INT_MIN;

        for (int i = 1; i < n * 2; ++i)
        {
            // 窗口长度大于 n 时弹出队首
            while (q.size() && i - q.front() > n)
                q.pop_front();

            // 更新最大子数组和
            res = std::max(res, s[i] - s[q.front()]);

            // 维护单调递增的队列
            while (q.size() && s[i] <= s[q.back()])
                q.pop_back();

            q.push_back(i);
        }

        return res;
    }
};

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;
    }
};

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; // 无法到达终点
    }
};

Clone Graph

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

133. 克隆图

分析

哈希表存储原节点与克隆节点的映射：
- 使用 hash 保存原图节点到克隆节点的映射关系，用于快速找到已克隆的节点，避免重复克隆
DFS 遍历图的所有节点：
- 对每个未访问过的节点，创建其克隆节点并存入 hash
- 遍历当前节点的所有邻居，如果邻居未被克隆，则递归处理
复制邻接关系：
- 遍历所有节点（已在 hash 中），将每个原节点的邻居对应的克隆节点添加到克隆节点的邻居列表中
最终返回起始节点的克隆版本，即为完整的深拷贝图

时间复杂度

图的所有节点和边都会被访问一次，因此时间复杂度为 O(N + E)，其中 N 是节点数，E 是边数

空间复杂度

递归调用栈的深度取决于图的结构，最坏情况下为 O(N)，加上哈希表的存储空间，总体复杂度为 O(N)

C++代码

class Solution
{
public:
    Node* cloneGraph(Node* node)
    {
        if (!node)
            return nullptr;

        std::unordered_map<Node*, Node*> hash; // 哈希表存储节点映射
        dfs(node, hash); // 深度优先搜索创建克隆节点

        // 第二次遍历复制邻接关系
        for (auto& [origin, copy] : hash)
            for (Node* neighbor : origin->neighbors)
                copy->neighbors.push_back(hash[neighbor]); // 将原节点的邻接点的克隆节点添加到克隆节点的邻接表中

        return hash[node]; // 返回克隆图的起点
    }

    void dfs(Node* node, std::unordered_map<Node*, Node*>& hash)
    {
        // 克隆当前节点
        hash[node] = new Node(node->val);

        // 递归克隆邻居节点
        for (Node* neighbor : node->neighbors)
            if (hash.count(neighbor) == 0) // 如果邻居未被克隆
                dfs(neighbor, hash); // 递归处理
    }
};

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;
    }
};

Sum Root To Leaf Numbers

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

129. 求根节点到叶节点数字之和

分析

递归遍历二叉树：使用深度优先搜索遍历树，从根节点开始，到达每个叶节点时，记录下从根到当前节点的路径形成的数字
路径数字的累加：在遍历过程中，将当前节点的值添加到路径上，形成当前路径的数字。在到达叶节点时，将该数字加入总和
返回结果：最终返回计算得到的所有路径之和

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    int sumNumbers(TreeNode* root)
    {
        int res = 0;
        // 如果根节点非空，开始递归
        if (root)
            dfs(root, res, 0);
        return res;
    }

    void dfs(TreeNode* root, int& res, int cur)
    {
        // 将当前节点的值加到当前路径的数字中
        cur = cur * 10 + root->val;

        // 如果当前节点是叶节点，将路径数字加到结果中
        if (!root->left && !root->right)
            res += cur;

        // 继续递归遍历左子树
        if (root->left)
            dfs(root->left, res, cur);

        // 继续递归遍历右子树
        if (root->right)
            dfs(root->right, res, cur);
    }
};

Construct Binary Tree From Inorder And Postorder Traversal

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

106. 从中序和后序遍历序列构造二叉树

分析

构建哈希表：
- 遍历 inorder 数组，用哈希表记录每个节点值的位置。
- 这样可以快速查找某个节点在中序遍历中的索引。
递归划分左右子树：
- 后序遍历的最后一个元素是根节点。
- 在中序遍历中找到根节点的位置，从而确定左子树和右子树的范围。
递归构造树：
- 通过子数组的范围递归构造左右子树。
- 递归的边界条件是子数组范围为空。
返回结果：
- 最终返回根节点，即整棵树的构造结果

时间复杂度

构造哈希表需要 O(n)
每次递归通过哈希表查找根节点位置是 O(1)，递归调用总次数为 n，因此递归部分的时间复杂度为 O(n)

总时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::unordered_map<int, int> hash; // 记录中序遍历中每个节点值的位置

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
    {
        // 构建哈希表，快速查找中序遍历中每个节点的位置
        for (int i = 0; i < inorder.size(); ++i)
            hash[inorder[i]] = i;

        // 调用递归函数构造二叉树
        return build(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
    }

    TreeNode* build(std::vector<int>& inorder, std::vector<int>& postorder, int il, int ir, int pl, int pr)
    {
        // 如果子树范围为空，返回空节点
        if (il > ir)
            return nullptr;

        // 获取当前子树的根节点
        TreeNode* root = new TreeNode(postorder[pr]);
        int mid = hash[root->val]; // 在中序遍历中找到根节点的位置

        // 递归构造左子树
        root->left = build(inorder, postorder, il, mid - 1, pl, pl + mid - 1 - il);

        // 递归构造右子树
        root->right = build(inorder, postorder, mid + 1, ir, pl + mid - 1 - il + 1, pr - 1);

        return root;
    }
};

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; // 返回处理后的根节点
    }
};

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);
    }
};

Basic Calculator

Sun, 19 Jan 2025 00:00:00 +0000

224. 基本计数器

分析

栈处理运算：使用两个栈：
- nums 栈：存储操作数
- op 栈：存储操作符
遍历字符串：
- 如果是数字，将数字读完整并压入 nums 栈
- 如果是操作符，比较当前操作符与 op 栈顶操作符的优先级：
  - 如果栈顶优先级更高或相同，执行计算并将结果压入 nums 栈
  - 否则，将当前操作符压入 op 栈
- 如果是左括号 (，直接压入 op 栈
- 如果是右括号 )，弹出并计算直到遇到左括号
清算剩余操作：遍历结束后，计算栈中剩余的操作符，最终返回结果

时间复杂度

遍历字符串 s 的每个字符：O(n)
每个操作符最多计算一次：O(n)

总时间复杂度为 O(n)

空间复杂度

使用了两个栈 nums 和 op，最坏情况下同时存储 n 个字符（例如全为数字或括号），空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::stack<int> nums;         // 存储操作数
    std::stack<char> op;          // 存储操作符

    // 执行栈顶一次运算
    void eval()
    {
        int b = nums.top(); nums.pop();
        int a = nums.top(); nums.pop();
        char c = op.top(); op.pop();
        if (c == '+')
            nums.push(a + b);
        else if (c == '-')
            nums.push(a - b);
        else if (c == '*')
            nums.push(a * b);
        else
            nums.push(a / b);
    }

    // 字符串替换函数
    void replace(std::string& s, std::string src, std::string dest)
    {
        int pos = s.find(src), n = src.size();
        while (pos != std::string::npos)
        {
            s.replace(pos, n, dest);
            pos = s.find(src);
        }
    }

    // 主函数
    int calculate(string s)
    {
        // 去掉空格，处理括号中的正负号
        replace(s, " ", "");
        replace(s, "(+", "(0+");
        replace(s, "(-", "(0-");
        nums.push(0);  // 初始化 nums 栈，避免边界条件

        // 定义操作符优先级
        std::unordered_map<char, int> priority_op{{'-', 1}, {'+', 1}, {'/', 2}, {'*', 2}};

        // 遍历表达式
        for (int i = 0; i < s.size(); ++i)
        {
            if (isdigit(s[i]))
            { // 处理数字
                int num = 0, j = i;
                while (j < s.size() && isdigit(s[j]))
                    num = num * 10 + (s[j++] - '0');
                nums.push(num); // 数字入栈
                i = j - 1;      // 更新索引
            }
            else if (s[i] == '(')
            { // 左括号直接入栈
                op.push(s[i]);
            } else if (s[i] == ')')
            { // 右括号
                while (op.size() && op.top() != '(')
                    eval(); // 计算括号内表达式
                op.pop(); // 弹出左括号
            }
            else
            { // 遇到操作符
                while (op.size() && op.top() != '(' && priority_op[op.top()] >= priority_op[s[i]])
                    eval(); // 优先级高于当前操作符时，计算
                op.push(s[i]); // 当前操作符入栈
            }
        }

        // 清算剩余操作
        while (op.size())
            eval();

        return nums.top();
    }
};

Insertion Sort List

Sun, 19 Jan 2025 00:00:00 +0000

147. 对链表进行插入排序

分析

使用一个虚拟头节点 dummy 来方便构建有序链表
遍历原链表：
- 对于当前节点 p，从虚拟头节点 dummy 开始查找它应插入的位置
- 插入后调整指针以确保链表仍然连接正确
继续处理下一节点，直到原链表遍历结束
返回排序后的链表

时间复杂度

外层遍历链表，每个节点插入有序链表的过程中需查找插入位置。
最坏情况下（链表反序），插入每个节点需要遍历整个有序链表，时间复杂度为 O(n^2)，其中 n 是链表的长度

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* insertionSortList(ListNode* head)
    {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        ListNode* p = head;

        // 遍历原链表
        while (p)
        {
            // 找到插入点：从 dummy 开始找到第一个大于当前节点值的位置
            ListNode* cur = dummy;
            while (cur->next && cur->next->val <= p->val)
                cur = cur->next;

            // 插入当前节点到有序链表
            ListNode* next = p->next;  // 保存下一个节点
            p->next = cur->next;      // 当前节点指向插入位置后的节点
            cur->next = p;            // 插入当前节点到有序链表
            p = next;                 // 继续处理下一个节点
        }

        // 返回排序后的链表
        return dummy->next;
    }
};

Partition List

Sun, 19 Jan 2025 00:00:00 +0000

86. 分隔链表

分析

使用两个虚拟头节点 small_head 和 big_head 分别构建两条子链表：

遍历原链表，对于每个节点：
- 如果值小于 x，将该节点添加到以 small_head 为头的链表
- 如果值大于或等于 x，将该节点添加到以 big_head 为头的链表
遍历结束后，将小链表的尾部连接到大链表的头部
返回合并后的链表（从 small_head->next 开始）

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* partition(ListNode* head, int x)
    {
        // 初始化两个虚拟头节点和尾指针
        auto small_head = new ListNode(-1), big_head = new ListNode(-1);
        auto small_tail = small_head, big_tail = big_head;

        // 遍历链表，分隔节点
        for (auto p = head; p; p = p->next)
        {
            if (p->val < x)
                small_tail = small_tail->next = p; // 添加到小链表
            else
                big_tail = big_tail->next = p;    // 添加到大链表
        }

        // 合并两部分链表
        small_tail->next = big_head->next;
        big_tail->next = NULL; // 确保大链表尾部没有残留节点

        return small_head->next; // 返回分隔后的链表
    }
};

Evaluate Reverse Polish Notation

Sat, 18 Jan 2025 00:00:00 +0000

150. 逆波兰表达式求值

分析

遍历 tokens 数组，对于每个元素：
- 如果是数字，将其转换为整数并压入栈中
- 如果是运算符，弹出栈顶的两个数字进行运算，并将结果压回栈中
最后，栈中会留下一个元素，这个元素即为整个表达式的结果

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int evalRPN(vector<string>& tokens)
    {
      std::stack<int> stk;  // 用来存储操作数
      for (std::string& token : tokens)
      {
        // 如果是运算符，弹出两个元素进行运算
        if (token == "+" || token == "-" || token == "/" || token == "*")
        {
          int b = stk.top();  // 弹出栈顶元素作为右操作数
          stk.pop();
          int a = stk.top();  // 弹出新的栈顶元素作为左操作数
          stk.pop();

          // 进行相应的运算，并将结果压回栈中
          if (token == "+")
            stk.push(a + b);
          else if (token == "-")
            stk.push(a - b);
          else if (token == "/")
            stk.push(a / b);
          else
            stk.push(a * b);
        }
        else  // 如果是数字，直接将其转换为整数压入栈中
        {
          stk.push(stoi(token));
        }
      }
      return stk.top();  // 返回栈中的唯一元素，即计算结果
    }
};

Insert Interval

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

57. 插入区间

分析

遍历并处理不重叠区间（在 newInterval 左侧）：
- 将所有结束小于 newInterval 开始的区间直接加入结果集
合并重叠区间（与 newInterval 重叠）：
- 从当前位置开始，合并所有与 newInterval 有重叠的区间。合并时更新 newInterval 的左右边界：
  - 左边界取两者最小值 l = min(l, intervals[k][0])
  - 右边界取两者最大值 r = max(r, intervals[k][1])
插入合并后的新区间：
- 将合并后的新区间 [l, r] 插入结果集。
添加剩余区间（在 newInterval 右侧）：
- 将剩下的、与 newInterval 不重叠的区间加入结果集。

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval)
    {
        std::vector<std::vector<int>> res;
        int k = 0, n = intervals.size();
        int l = newInterval[0], r = newInterval[1];

        // 1. 将 newInterval 左侧不重叠的区间加入结果
        while (k < n && intervals[k][1] < l) {
            res.push_back(intervals[k]);
            ++k;
        }

        // 2. 合并所有与 newInterval 重叠的区间
        if (k < n) {
            l = std::min(l, intervals[k][0]);  // 更新合并区间的左边界
            while (k < n && intervals[k][0] <= r) {
                r = std::max(r, intervals[k][1]);  // 更新合并区间的右边界
                ++k;
            }
        }
        res.push_back({l, r});  // 3. 插入合并后的区间

        // 4. 将 newInterval 右侧不重叠的区间加入结果
        while (k < n) {
            res.push_back(intervals[k]);
            ++k;
        }

        return res;
    }
};

Simplify Path

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

71. 简化路径

分析

追加斜杠便于分割：
- 为避免手动处理路径末尾的文件夹，先在路径末尾添加一个 '/'。这样每个目录（或命令）都会被完整处理
逐字符遍历构建当前目录：
- 遇到非 '/' 字符时，累积到 cur，表示当前目录名
- 遇到 '/' 时，处理当前累积的 cur：
  - ".."：回退到上一级目录
  - "." 或空字符串：忽略
  - 普通目录名：追加到结果路径 res
处理返回结果：
- 如果结果字符串 res 为空，返回根目录 '/'；否则返回简化后的路径

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    string simplifyPath(string path)
    {
        std::string res, cur;

        // 1. 确保末尾有 '/'，方便处理最后一个目录
        if (path.back() != '/')
            path += '/';

        // 2. 遍历路径
        for (char c : path)
        {
            if (c != '/')  // 累积目录名
                cur += c;
            else  // 遇到 '/'，处理当前目录
            {
                if (cur == "..")  // 返回上一级目录
                {
                    // 删除上一级目录
                    while (!res.empty() && res.back() != '/')
                        res.pop_back();  // 删除目录名

                    if (!res.empty())
                        res.pop_back();  // 删除 '/'
                }
                else if (cur != "." && !cur.empty())  // 忽略 "." 和空字符串
                {
                    res += "/" + cur;  // 加入新目录
                }
                cur.clear();  // 重置当前目录
            }
        }

        // 3. 返回结果
        return res.empty() ? "/" : res;
    }
};

Summary Ranges

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

228. 汇总区间

分析

遍历数组：用双指针 i 和 j 遍历数组，识别连续递增的数字区间
扩展区间：如果当前数字和前一个数字连续 nums[j] == nums[j-1] + 1，继续扩大区间
记录区间：
- 如果区间内只有一个数字 j == i + 1，直接记录该数字
- 如果区间内有多个数字 j > i + 1，记录区间 “起始值->结束值”
跳过已处理的区间：将 i 更新为区间的最后一个元素 i = j - 1，继续查找下一个区间

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    vector<string> summaryRanges(vector<int>& nums)
    {
        std::vector<std::string> res;  // 存储结果
        int n = nums.size();

        for (int i = 0; i < n; ++ i)
        {
            int j = i + 1;
            // 扩展区间，找到连续的数字
            while (j < n && nums[j] == nums[j - 1] + 1)
                ++ j;

            std::ostringstream oss;  // 用于拼接字符串
            if (j == i + 1)  // 区间内只有一个数字
                oss << nums[i];
            else  // 区间内有多个连续数字
                oss << nums[i] << "->" << nums[j - 1];

            res.push_back(oss.str());  // 将区间结果加入结果集
            i = j - 1;  // 跳过已处理的区间
        }
        return res;
    }
};

Contains Duplicate

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

219. 存在重复元素II

分析

哈希表记录元素索引
- 用一个哈希表来记录每个元素上一次出现的索引。
遍历数组并检查条件
- 每次遍历到当前元素时，检查该元素是否已经存在于哈希表中：
  - 如果存在，比较当前索引和之前索引的差值是否小于等于 k，满足则返回 true
  - 如果不存在，或差值大于 k，则更新该元素的索引为当前索引
遍历结束仍未找到符合条件的元素，则返回 false

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k)
    {
        std::unordered_map<int, int> hash;  // 用于存储元素及其最后一次出现的索引

        for (int i = 0; i < nums.size(); ++ i)
        {
            // 如果当前元素之前出现过，且索引之差小于等于 k
            if (hash.count(nums[i]) && i - hash[nums[i]] <= k)
                return true;  // 满足条件，直接返回 true

            hash[nums[i]] = i;  // 更新当前元素的索引
        }

        return false;  // 遍历结束未找到符合条件的元素，返回 false
    }
};

Happy Number

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

202. 快乐数

分析

计算每位数字的平方和
- 创建一个函数 happy(n)，计算整数 n 每位数字的平方和
检测循环
- 使用哈希集合记录每次计算的结果，防止无限循环
- 如果平方和结果重复出现，说明进入了死循环，返回 false
- 如果平方和结果变成 1，返回 true

时间复杂度

时间复杂度 O(logn)

空间复杂度

空间复杂度为 O(logn)

C++代码

class Solution
{
public:
    // 辅助函数：计算一个数的每位数字的平方和
    int happy(int n)
    {
        int sum = 0;
        while (n)
        {
            int t = n % 10;      // 取出最低位数字
            sum += t * t;        // 平方后累加
            n /= 10;             // 去掉最低位
        }
        return sum;
    }

    // 主函数：判断是否为快乐数
    bool isHappy(int n)
    {
        std::unordered_set<int> hash;  // 记录已出现的平方和结果

        while (n != 1)
        {
            n = happy(n);              // 计算平方和
            if (hash.count(n))         // 如果结果重复出现，说明进入循环
                return false;
            hash.insert(n);            // 记录当前结果
        }
        return true;                   // 最终变成 1，返回 true
    }
};

Valid Anagram

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

242. 有效的字母异位词

分析

使用哈希表统计字符频次
- 分别遍历 s 和 t，统计每个字符的出现次数
- 使用两个哈希表 hashS 和 hashT 存储字符频次
比较两个哈希表是否相等
- 如果两个哈希表相等，说明两个字符串是字母异位词
- 如果不相等，说明字符种类或字符次数不同，返回 false
时间复杂度：O(n)
- 遍历两个字符串各一次
空间复杂度：O(n)
- 使用哈希表存储字符频次

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool isAnagram(string s, string t)
    {
        std::unordered_map<char, int> hashS, hashT;

        // 1. 统计字符串 s 的字符频次
        for (char c : s)
            ++hashS[c];

        // 2. 统计字符串 t 的字符频次
        for (char c : t)
            ++hashT[c];

        // 3. 比较两个哈希表是否相等
        return hashS == hashT;
    }
};

Isomorphic Strings

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

205. 同构字符串

分析

双向映射：
- 用两个哈希表建立双向映射关系。
  - st：记录从 s 到 t 的映射
  - ts：记录从 t 到 s 的映射
逐字符映射检查：
- 遍历字符串，检查每一对字符是否满足映射规则：
  - 如果 s[i] 已经映射到某个字符，但不是 t[i]，则返回 false
  - 如果 t[i] 已经映射到某个字符，但不是 s[i]，则返回 false
合法映射：
- 如果遍历结束都没有冲突，返回 true

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool isIsomorphic(string s, string t)
    {
        // 1. 创建两个哈希表：s -> t 和 t -> s
        std::unordered_map<char, char> st, ts;

        // 2. 遍历字符串
        for (int i = 0; i < s.size(); ++i)
        {
            char a = s[i], b = t[i];

            // 3. 检查 s -> t 的映射关系是否冲突
            if (st.count(a) && st[a] != b)
                return false;

            // 4. 建立 s -> t 的映射
            st[a] = b;

            // 5. 检查 t -> s 的映射关系是否冲突
            if (ts.count(b) && ts[b] != a)
                return false;

            // 6. 建立 t -> s 的映射
            ts[b] = a;
        }

        // 7. 映射无冲突，返回 true
        return true;
    }
};

Ransom Note

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

383. 赎金信

分析

构建字符频率表
- 遍历 magazine，统计每个字符出现的次数。
逐字符匹配
- 如果 hash[c] > 0，说明字符可用，使用后数量减 1
- 如果 hash[c] == 0，说明字符不足，返回 false
全部匹配成功
- 如果遍历完 ransomNote 没有提前返回 false，则说明可以成功构造，返回 true

时间复杂度

时间复杂度 O(n + m)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool canConstruct(string ransomNote, string magazine)
    {
        // 1. 统计 magazine 中字符的频率
        std::unordered_map<char, int> hash;
        for (char c : magazine)
            ++ hash[c];  // 每个字符的出现次数

        // 2. 遍历 ransomNote，检查字符是否足够
        for (char c : ransomNote)
        {
            if (hash[c] > 0)
                --hash[c];  // 使用一个字符，数量减少
            else
                return false;  // 不足时，直接返回 false
        }

        // 3. 所有字符都有足够数量，返回 true
        return true;
    }
};

Word Pattern

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

290. 单词规律

分析

分割字符串：
- 将字符串 s 按空格分割成单词列表 words
长度判断：
- 如果 pattern 的长度 ≠ words 的数量，直接返回 false
建立双向映射：
- 使用两个哈希表：
  - ps：pattern 的字符 → s 的单词
  - sp：s 的单词 → pattern 的字符
遍历检查：
- 遍历 pattern 和 words：
  - 如果 ps 中字符的映射与当前单词不一致，返回 false
  - 如果 sp 中单词的映射与当前字符不一致，返回 false
  - 否则建立新的映射关系。
全部检查通过，返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool wordPattern(string pattern, string s)
    {
        std::vector<std::string> words;

        // 1. 将 s 按空格分割成单词
        for (int i = 0; i < s.size(); ++i)
        {
            int j = i + 1;
            while (j < s.size() && s[j] != ' ')  // 找到单词的结束位置
                ++ j;
            words.push_back(s.substr(i, j - i));  // 提取单词
            i = j;  // 移动到下一个单词
        }

        // 2. 长度不一致，直接返回 false
        if (pattern.size() != words.size())
            return false;

        // 3. 建立双向映射
        std::unordered_map<char, std::string> ps;  // pattern → word
        std::unordered_map<std::string, char> sp;  // word → pattern

        // 4. 遍历 pattern 和 words
        for (int i = 0; i < pattern.size(); ++i)
        {
            char a = pattern[i];
            std::string b = words[i];

            // 5. 检查 pattern → word 映射
            if (ps.count(a) && ps[a] != b)
                return false;
            ps[a] = b;

            // 6. 检查 word → pattern 映射
            if (sp.count(b) && sp[b] != a)
                return false;
            sp[b] = a;
        }

        // 7. 映射关系正确，返回 true
        return true;
    }
};

Game of Life

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

289. 生命游戏

分析

原地更新（不额外开辟空间）：
- 直接在原矩阵 board 上更新，但在更新过程中要避免影响到邻居细胞的判断
状态编码（利用位运算存储两种状态）：
- 最低位（第 0 位）：当前细胞的状态（0 = 死，1 = 活）
- 次低位（第 1 位）：细胞的下一状态（0 = 死，1 = 活）
计算邻居活细胞数：
- 邻居遍历（避免越界）
  - x ∈ [max(0, i - 1), min(i + 1, n - 1)]
  - y ∈ [max(0, j - 1), min(j + 1, m - 1)]
  - 跳过自己：(x != i || y != j)
- 遍历细胞的八个邻居，board[i][j] & 1 提取当前状态，统计当前活细胞数
按规则更新下一状态：
- 活细胞 → 存活（2~3 个邻居活细胞），否则死亡
- 死细胞 → 恰好 3 个邻居活细胞复活
- board[i][j] |= (next << 1) 将下一状态存入次低位
更新完成后右移一位：
- board[i][j] >>= 1，将下一状态更新为当前状态

时间复杂

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

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    void gameOfLife(vector<vector<int>>& board)
    {
        int n = board.size(), m = board[0].size();
        if (n == 0 || m == 0)
            return;

        // 遍历每个细胞，计算下一状态
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < m; ++j)
            {
                int live = 0;  // 统计周围活细胞数

                // 遍历周围 8 个方向
                for (int x = max(0, i - 1); x <= min(i + 1, n - 1); ++x)
                {
                    for (int y = max(0, j - 1); y <= min(j + 1, m - 1); ++y)
                    {
                        if ((x != i || y != j) && (board[x][y] & 1))
                            ++live;  // 只看当前状态（最低位）
                    }
                }

                int cur = board[i][j];  // 当前状态
                int next = 0;           // 下一状态

                // 按规则更新下一状态
                if (cur & 1)
                {  // 当前是活细胞
                    if (live == 2 || live == 3)
                        next = 1;  // 继续存活
                    else
                        next = 0;  // 死亡
                }
                else
                {  // 当前是死细胞
                    if (live == 3)
                        next = 1;  // 复活
                    else
                        next = 0;  // 继续死亡
                }

                board[i][j] |= (next << 1);  // 更新下一状态到次低位
            }
        }

        // 右移 1 位，更新到当前状态
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                board[i][j] >>= 1;
    }
};

Substr with Concatenation of All Words

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

30. 串联所有单词的子串

分析

窗口长度固定：
- 每个单词长度相同，假设单词长度为 w，words 长度为 m，则窗口长度为 m * w
哈希表记录单词频次：
- 使用哈希表 total 统计 words 中每个单词出现的次数
- 窗口内部用另一个哈希表 window 统计窗口内单词频次
多起点滑动窗口：
- 从 s 的下标 0 ~ w - 1 依次滑动，确保不会遗漏跨单词边界的情况
窗口内单词匹配：
- 每次从当前位置提取长度为 w 的单词，更新窗口哈希表
- 如果窗口内单词频次超过 words 中的频次，则收缩窗口
- 当窗口内单词频次与 words 完全一致时，记录窗口的起始位置

时间复杂度

外层循环 w 次（单词长度）
内层遍历 n / w 次，每次提取单词和更新哈希表，代价为 O(1)

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

空间复杂度

空间复杂度为 O(m)

C++代码

class Solution
{
public:
    vector<int> findSubstring(string s, vector<string>& words)
    {
        std::vector<int> res;
        if (words.empty())  // 边界情况：words为空
            return res;

        int n = s.size();             // 字符串 s 的长度
        int m = words.size();         // 单词个数
        int w = words[0].size();      // 单词长度

        // 统计 words 中每个单词出现的次数
        std::unordered_map<std::string, int> total;
        for (std::string& word : words)
            ++ total[word];

        // 遍历所有可能的起始位置（避免跨单词边界）
        for (int i = 0; i < w; ++i)
        {
            std::unordered_map<std::string, int> window;  // 窗口内单词频次
            int cnt = 0;  // 匹配到的单词数

            // 滑动窗口，步长为 w（单词长度）
            for (int j = i; j + w <= n; j += w)
            {
                // 当前窗口右侧加入新单词
                std::string rightWord = s.substr(j, w);
                ++ window[rightWord];
                if (window[rightWord] <= total[rightWord])  // 新单词未超额
                    ++ cnt;

                // 如果窗口超过了大小 m * w，滑动窗口左侧
                if (j >= i + m * w)
                {
                    std::string leftWord = s.substr(j - m * w, w);
                    -- window[leftWord];
                    if (window[leftWord] < total[leftWord])  // 如果减少后不匹配
                        -- cnt;
                }

                // 匹配到所有单词，记录起始索引
                if (cnt == m)
                    res.push_back(j - (m - 1) * w);
            }
        }
        return res;
    }
};

Valid Sudoku

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

36. 有效的数独

分析

行检查：
- 遍历每一行，使用布尔数组记录数字是否出现过
列检查：
- 遍历每一列，使用布尔数组记录数字是否出现过
3×3 宫格检查：
- 每个 3×3 宫格起点分别是 (0,0)、(0,3)、(0,6)、(3,0)…
- 遍历每个小宫格，判断是否有重复数字
数字映射：
- 将字符 '1'~'9' 转换成索引 0 ~ 8，方便标记
发现重复直接返回 false，全部通过返回 true

时间复杂度

总时间复杂度 O(1)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool isValidSudoku(vector<vector<char>>& board)
    {
        std::vector<bool> st(9);  // 标记数组，记录数字是否出现

        // 1. 检查每一行
        for (int i = 0; i < 9; ++i)
        {
            st = std::vector<bool>(9, false);  // 重置标记
            for (int j = 0; j < 9; ++j)
            {
                if (board[i][j] != '.')
                {
                    int num = board[i][j] - '1';  // 映射到 0~8
                    if (st[num])  // 数字重复
                        return false;
                    st[num] = true;  // 标记出现过
                }
            }
        }

        // 2. 检查每一列
        for (int i = 0; i < 9; ++i)
        {
            st = std::vector<bool>(9, false);  // 重置标记
            for (int j = 0; j < 9; ++j)
            {
                if (board[j][i] != '.')
                {
                    int num = board[j][i] - '1';
                    if (st[num])  // 数字重复
                        return false;
                    st[num] = true;
                }
            }
        }

        // 3. 检查每个 3×3 宫格
        for (int i = 0; i < 9; i += 3)
            for (int j = 0; j < 9; j += 3)
            {
                st = std::vector<bool>(9, false);  // 重置标记
                for (int x = 0; x < 3; ++x)
                    for (int y = 0; y < 3; ++y)
                    {
                        if (board[i + x][j + y] != '.')
                        {
                            int num = board[i + x][j + y] - '1';
                            if (st[num])  // 数字重复
                                return false;
                            st[num] = true;
                        }
                    }
            }

        return true;  // 所有检查通过
    }
};

Minimum Size Subarray Sum

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

209. 长度最小的子数组

分析

定义窗口区间：使用两个指针 i 和 j 表示滑动窗口的左右边界
窗口扩展：从左到右遍历数组，不断将元素加入当前窗口 sum += nums[i]
窗口收缩：
- 当窗口内的子数组和 target，尝试通过移动左指针 j 来缩小窗口，寻找更短的子数组
- 每次收缩时更新最小长度：res = min(res, i - j + 1)
返回结果：
- 如果没有找到符合条件的子数组，返回 0
- 否则，返回记录的最短长度

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int minSubArrayLen(int target, vector<int>& nums)
    {
        int res = INT_MAX;  // 初始化最小长度为无穷大
        int sum = 0;        // 窗口内子数组的和
        int j = 0;          // 左指针

        for (int i = 0; i < nums.size(); ++ i)  // 遍历数组
        {
            sum += nums[i];  // 扩大窗口（右指针右移）

            // 收缩窗口（左指针右移），直到和 < target
            while (sum - nums[j] >= target)
            {
                sum -= nums[j];  // 移除窗口左边的元素
                ++ j;             // 左指针右移
            }

            // 如果当前窗口和 >= target，更新最小长度
            if (sum >= target)
                res = std::min(res, i - j + 1);
        }

        // 如果没有符合条件的子数组，返回 0
        return res == INT_MAX ? 0 : res;
    }
};

Two Sum II

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

167. 两数之和II

分析

初始化两个指针：
- 左指针 i = 0（指向数组开头）
- 右指针 j = n - 1（指向数组末尾）
双指针移动规则：
- 计算 numbers[i] + numbers[j]：
  - 等于 target → 返回 [i + 1, j + 1]（下标从 1 开始）
  - 大于 target → 右指针左移（减小和）
  - 小于 target → 左指针右移（增大和）
终止条件：
- 当 i >= j 时，搜索结束

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    vector<int> twoSum(vector<int>& numbers, int target)
    {
        for (int i = 0, j = numbers.size() - 1; i < j; ++i)  // 初始化双指针
        {
            while (i < j && numbers[i] + numbers[j] > target) // 如果和大于目标，右指针左移
                -- j;

            if (i < j && numbers[i] + numbers[j] == target)   // 找到目标和
                return {i + 1, j + 1};  // 返回结果（下标从1开始）
        }
        return {};  // 如果没有找到，返回空数组
    }
};

Valid Palindrome

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

125. 验证回文串

分析

字符校验 check 函数：
- 判断字符是否在 '0'-'9'、'a'-'z' 或 'A'-'Z' 范围内
双指针遍历：
- 左指针 i 从前往后，右指针 j 从后往前
- 遇到非字母数字字符，分别跳过 ++i 或 --j
- 比较两端字符（忽略大小写），如果不同，则返回 false
结束条件：
- 如果所有字符都匹配，则返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    // 辅助函数：判断字符是否是字母或数字
    bool check(char c)
    {
        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }

    bool isPalindrome(string s)
    {
        // 双指针初始化
        for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
        {
            // 左指针跳过非字母数字字符
            while (i < j && !check(s[i]))
                ++ i;

            // 右指针跳过非字母数字字符
            while (i < j && !check(s[j]))
                -- j;

            // 比较左右字符（忽略大小写）
            if (i < j && ::tolower(s[i]) != ::tolower(s[j]))
                return false;
        }
        return true;
    }
};

Find the Index of the First Occurrence In a String

Sun, 12 Jan 2025 00:00:00 +0000

28. 找出字符串中第一个匹配项的下标

分析

解题思路：KMP 算法

为了高效地查找子串，KMP 算法（Knuth-Morris-Pratt）通过构建部分匹配表 next 数组，在匹配失败时跳过不必要的字符比较，避免重复匹配

构建部分匹配表（next数组）
- 含义：next[i] 表示 needle[0...i] 的最长相等前后缀长度
- 作用：当匹配失败时，needle 可以直接跳到合适的位置，减少比较次数
构建过程：
- 用两个指针：i 遍历 needle，j 记录当前最长前后缀长度
- 如果 needle[i] == needle[j]，则 j++，更新 next[i] = j
- 如果不相等，回溯 j = next[j - 1]
主串匹配
- 用两个指针：i 遍历 haystack，j 遍历 needle
- 如果字符相等，i ++，j ++
- 如果不相等，则 j 回溯到 next[j - 1]
- 当 j == needle.size()，表示完全匹配，返回起始下标 i - m + 1

时间复杂度

构建 next 数组：O(m)
主串匹配：O(n)

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

空间复杂度

空间复杂度为 O(m)

C++代码

class Solution
{
public:
    int strStr(string haystack, string needle)
    {
        int n = haystack.size(), m = needle.size();
        if (m == 0)  // 特殊情况：needle为空，返回0
            return 0;

        // 构建next数组
        std::vector<int> next(m);
        for (int i = 1, j = 0; i < m; ++i)
        {
            while (j > 0 && needle[i] != needle[j])  // 回退
                j = next[j - 1];
            if (needle[i] == needle[j])  // 匹配成功
                ++j;
            next[i] = j;  // 更新next数组
        }

        // 匹配过程
        for (int i = 0, j = 0; i < n; ++i)
        {
            while (j > 0 && haystack[i] != needle[j])  // 回退
                j = next[j - 1];
            if (haystack[i] == needle[j])  // 匹配成功
                ++j;
            if (j == m)  // 完全匹配
                return i - m + 1;
        }

        return -1;  // 匹配失败
    }
};

Length of Last Word

Sun, 12 Jan 2025 00:00:00 +0000

58. 最后一个单词的长度

分析

从后往前遍历：
- 从字符串末尾开始，跳过尾随空格
- 遇到第一个非空格字符，开始计数，直到遇到空格或遍历结束
计数计算：
- 遇到空格时，说明最后一个单词已遍历完，返回单词长度
- 如果整个字符串遍历完，仍未遇到空格，说明字符串只有一个单词

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int lengthOfLastWord(string s)
    {
        // 从字符串末尾开始遍历
        for (int i = s.size() - 1; i >= 0; --i)
        {
            if (s[i] == ' ')  // 跳过尾随空格
                continue;

            int j = i - 1;
            // 找到当前单词的起始位置
            while (j >= 0 && s[j] != ' ')
                --j;

            // 单词长度 = 结束位置 - 起始位置
            return i - j;
        }
        return 0;  // 字符串全是空格时返回 0
    }
};

Text Justification

Sun, 12 Jan 2025 00:00:00 +0000

68. 文本左右对齐

分析

分组单词（贪心）：
- 用指针 i 表示当前行的起始单词，j 表示下一个单词
- 不断尝试加入下一个单词，直到超出 maxWidth
构建每一行：
- 左对齐（最后一行或只有一个单词）：单词之间加 1 个空格，末尾补空格
- 普通行：
  - 空格平均分配：空格总数 = maxWidth - 总单词长度
  - 多余空格优先分配到左侧。
  - 使用 std::string(n, ' ') 插入空格
更新索引：处理完当前行后，将 i 移动到下一行的起始单词

时间复杂度

遍历所有单词，每个单词最多被遍历两次（分组和拼接），时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<string> fullJustify(vector<string>& words, int maxWidth)
    {
        std::vector<std::string> res;  // 存储结果
        for (int i = 0; i < words.size(); ++i)
        {
            int j = i + 1;  // 下一个单词的索引
            int len = words[i].size();  // 当前行的总长度

            // 将尽可能多的单词放入当前行
            while (j < words.size() && len + 1 + words[j].size() <= maxWidth)
            {
                len += 1 + words[j].size();  // 单词加空格
                ++j;
            }

            std::string line;  // 构建当前行内容

            // 情况1：最后一行或当前行只有一个单词，左对齐
            if (j == i + 1 || j == words.size())
            {
                line += words[i];  // 加入第一个单词
                for (int k = i + 1; k < j; ++k)  // 后续单词前加空格
                    line += ' ' + words[k];

                // 补齐剩余空格
                while (line.size() < maxWidth)
                    line += ' ';
            }
            else
            {
                // 情况2：普通行（多单词，需均匀分配空格）
                int count = j - i - 1;  // 单词间隔数
                int space = maxWidth - len + count;  // 总空格数

                line += words[i];  // 加入第一个单词
                int k = 0;

                // 多余空格优先分配到左侧
                while (k < (space % count))
                {
                    line += std::string(space / count + 1, ' ') + words[i + k + 1];
                    ++k;
                }

                // 均匀分配剩余空格
                while (k < count)
                {
                    line += std::string(space / count, ' ') + words[i + k + 1];
                    ++k;
                }
            }

            res.push_back(line);  // 保存当前行
            i = j - 1;  // 更新索引，处理下一行
        }

        return res;
    }
};

Zigzag Conversion

Sun, 12 Jan 2025 00:00:00 +0000

6. Z字形变换

分析

特殊情况处理：
- 当 numRows = 1 时，Z 字形退化成一行，直接返回原字符串
分行遍历：
- 首行和尾行：字符之间的间隔是固定的 cycleLen = 2 * numRows - 2
- 中间行：每个周期内有两个字符，需要分别计算两个位置
结果拼接：
- 按行依次将字符加入结果字符串

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    string convert(string s, int numRows)
    {
        if (numRows == 1)  // 特殊情况处理
            return s;

        std::string res;
        int cycleLen = 2 * numRows - 2;  // 每个周期的长度

        for (int i = 0; i < numRows; ++i)  // 遍历每一行
        {
            if (i == 0 || i == numRows - 1)  // 首行和尾行
            {
                for (int j = i; j < s.size(); j += cycleLen)
                    res += s[j];
            }
            else  // 中间行
            {
                for (int j = i, k = cycleLen - i; j < s.size() || k < s.size(); j += cycleLen, k += cycleLen)
                {
                    if (j < s.size())  // 第一个字符
                        res += s[j];
                    if (k < s.size())  // 第二个字符（对称位置）
                        res += s[k];
                }
            }
        }
        return res;
    }
};

Candy

Sat, 11 Jan 2025 00:00:00 +0000

135. 分发糖果

分析

递归+记忆化搜索：
- 使用一个数组 candy 记录每个孩子应该分到的糖果数，初始值全为 1
- 对于每个孩子，递归判断左右相邻的孩子评分关系，更新糖果数量。
记忆化优化：
- 如果某个孩子的糖果数已计算过 candy[i] != 1，直接返回，避免重复计算
左右两侧递归更新：
- 如果左边孩子评分比当前孩子低，则当前孩子糖果数应该比左边多 1
- 如果右边孩子评分比当前孩子低，则当前孩子糖果数应该比右边多 1
累加结果：
- 遍历所有孩子，将糖果总数累加得到最少糖果数

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int candy(vector<int>& ratings)
    {
        int n = ratings.size();
        std::vector<int> candy(n, 1);  // 初始化每个孩子分 1 个糖果

        int res = 0;
        for (int i = 0; i < n; ++i)
            res += minCandy(ratings, candy, i);  // 递归更新糖果数

        return res;  // 返回总糖果数
    }

    // 递归函数：计算第 child 个孩子最少需要的糖果数
    int minCandy(std::vector<int>& ratings, std::vector<int>& candy, int child)
    {
        if (candy[child] != 1)  // 如果已计算过，直接返回
            return candy[child];

        // 左边孩子评分更低，当前孩子糖果+1
        if (child > 0 && ratings[child - 1] < ratings[child])
            candy[child] = std::max(candy[child], minCandy(ratings, candy, child - 1) + 1);

        // 右边孩子评分更低，当前孩子糖果+1
        if (child + 1 < ratings.size() && ratings[child] > ratings[child + 1])
            candy[child] = std::max(candy[child], minCandy(ratings, candy, child + 1) + 1);

        return candy[child];  // 返回计算结果
    }
};

Gas Station

Sat, 11 Jan 2025 00:00:00 +0000

134. 加油站

分析

模拟遍历：
- 从每个加油站 i 出发，模拟一圈是否能顺利到达终点
剩余油量判断：
- 每经过一个加油站，更新剩余油量 oil = oil + gas[k] - cost[k]
- 如果油量不足 oil < 0，说明从当前起点 i 无法完成一圈
跳过不可行区间：
- 如果从 i 出发失败，则从 i + step + 1 开始继续尝试，因为 i 到 i + step 之间的起点也无法成功
终止条件：
- 如果某次尝试走满了 n 步（即 step == n），说明该起点 i 能绕一圈，返回 i
- 如果所有加油站都尝试失败，则返回 -1

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost)
    {
        int n = gas.size(), step = 0;  // n 为加油站数量

        for (int i = 0; i < n;)  // 遍历每个加油站作为起点
        {
            int oil = 0;  // 当前剩余油量
            for (step = 0; step < n; ++step)
            {
                int k = (i + step) % n;  // 环形遍历加油站
                oil += gas[k] - cost[k];  // 更新剩余油量

                if (oil < 0)  // 如果油量不足，停止尝试
                    break;
            }

            if (step == n)  // 成功绕一圈
                return i;

            i = i + step + 1;  // 跳过失败区间，尝试下一个起点
        }

        return -1;  // 没有找到可行解
    }
};

Insert Delete Get Random

Sat, 11 Jan 2025 00:00:00 +0000

380. 时间插入、删除和获取随机元素

插入操作：
- 使用哈希表来存储元素及其索引，在 O(1) 时间内检查元素是否存在，并在数组末尾插入新元素
删除操作：
- 对于删除操作，不直接从哈希表中删除元素，而是用数组末尾的元素替代被删除的元素。这样可以在 O(1) 时间内移除元素，而不需要移动数组中的其它元素
随机访问操作：
- 使用一个数组来存储所有元素，借助数组的随机访问特性，可以在 O(1) 时间内获取一个随机元素

时间复杂度

insert(val)：哈希表的查找和插入操作都是 O(1)，数组的末尾插入也是 O(1)
remove(val)：删除操作中的查找、替换和哈希表更新都是 O(1)，数组末尾删除是 O(1)
getRandom()：通过 rand() 和数组索引的方式随机获取元素是 O(1)

空间复杂度

空间复杂度为 O(n)

C++ 代码

class RandomizedSet
{
public:
    std::unordered_map<int, int> hash;  // 存储元素及其索引
    std::vector<int> nums;  // 存储元素，支持随机访问

    // 初始化 RandomizedSet 对象
    RandomizedSet() {}

    // 插入元素 val
    bool insert(int val)
    {
        if (hash.count(val) == 0)
        {
            nums.push_back(val);  // 将 val 加入 nums 数组
            hash[val] = nums.size() - 1;  // 记录 val 在 nums 数组中的索引
            return true;
        }
        return false;
    }

    // 移除元素 val
    bool remove(int val)
    {
        if (hash.count(val))
        {
            int tail = nums.back();  // 获取数组末尾的元素
            int val_index = hash[val];  // 获取 val 在 nums 数组中的索引
            int tail_index = hash[tail];  // 获取数组末尾元素的索引

            // 将 val 和数组末尾元素交换
            std::swap(nums[val_index], nums[tail_index]);
            std::swap(hash[val], hash[tail]);

            nums.pop_back();  // 移除数组末尾元素
            hash.erase(val);  // 从哈希表中移除 val
            return true;
        }
        return false;
    }

    // 随机返回一个元素
    int getRandom()
    {
        return nums[rand() % nums.size()];  // 随机返回 nums 数组中的一个元素
    }
};

Python 代码

import random

class RandomizedSet:
    def __init__(self):
        self.val_to_idx = {}
        self.nums = []

    def insert(self, val: int) -> bool:
        if val in self.val_to_idx:
            return False
        self.nums.append(val)
        self.val_to_idx[val] = len(self.nums) - 1
        return True

    def remove(self, val: int) -> bool:
        if val not in self.val_to_idx:
            return False
        idx = self.val_to_idx[val]
        last_val = self.nums[-1]
        self.nums[idx] = last_val
        self.val_to_idx[last_val] = idx
        self.nums.pop()
        del self.val_to_idx[val]
        return True

    def getRandom(self) -> int:
        return random.choice(self.nums)

Go 代码

package main

import (
  "math/rand"
)

type RandomizedSet struct {
  valToIdx map[int]int
  nums []int
}

func Constructor() RandomizedSet {
  return RandomizedSet{
    valToIdx: make(map[int]int),
    nums: []int{},
  }
}

func (this *RandomizedSet) Insert(val int) bool {
  if _, exists := this.valToIdx[val]; exists {
    return false
  }
  this.nums = append(this.nums, val)
  this.valToIdx[val] = len(this.nums) - 1
  return true
}


func (this *RandomizedSet) Remove(val int) bool {
  idx, exists := this.valToIdx[val];
  if !exists {
    return false
  }
  last := this.nums[len(this.nums) - 1]
  this.nums[idx] = last
  this.valToIdx[last] = idx
  this.nums = this.nums[:len(this.nums) - 1]
  delete(this.valToIdx, val)
  return true
}

func (this *RandomizedSet) GetRandom() int {
  return this.nums[rand.Intn(len(this.nums))]
}

Best Time to Buy and Sell Stock II

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

122. 买卖股票的最佳时机II

分析

如果今天的股票价格比昨天高，就可以将这部分差价计入利润。这样相当于在每个上升区间都进行买入和卖出操作。将所有上涨的差价累加，即可获得最大利润

为什么这样是最优的？

股票可以在同一天买入和卖出，相当于在每个上涨区间及时买卖。
比如：[1, 2, 3, 4, 5]，买入 1 卖出 5 的利润和每天买卖 (1→2，2→3，3→4，4→5) 是相等的

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        int res = 0;  // 初始化总利润
        for (int i = 1; i < prices.size(); ++i)  // 遍历价格数组
            if (prices[i] > prices[i - 1])  // 如果今天比昨天贵
                res += prices[i] - prices[i - 1];  // 累加差价利润
        return res;  // 返回总利润
    }
};

H Index

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

274. H指数

算法

将引用次数降序排序。排序后，论文的引用次数是递减的，若第 i 篇论文（索引为 i - 1）的引用次数大于等于 i，则前面 i - 1 篇论文的引用次数也大于等于 i，，那么就有至少 i 篇论文的引用次数大于等于 i，即满足 H 指数条件

降序排序：
- 将引用次数从大到小排序，便于直接比较引用次数与当前索引 i
遍历判断：
- 从 i = n ~ 1（n 为论文总数），逐步判断
- 如果第 i 篇论文的引用次数 citations[i - 1] >= i，则满足 H 指数定义
- 返回当前 i 即为最大 H 指数
未找到满足条件的 H 指数：
- 如果遍历结束都没有找到，返回 0

复杂度分析

排序需要 O(nlogn) 时间，遍历一次数组 O(n)，总体时间复杂度为 O(nlogn)
空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int hIndex(vector<int>& citations)
    {
        // 1. 将引用次数降序排序
        std::sort(citations.begin(), citations.end(), std::greater<int>());

        // 2. 从大到小遍历，找到满足条件的最大 i
        for (int i = citations.size(); i > 0; -- i)
            if (citations[i - 1] >= i)
                return i;  // 找到最大 i，直接返回

        // 3. 如果没有满足条件的 i，返回 0
        return 0;
    }
};

Python 代码

class Solution:
    def hIndex(self, citations: List[int]) -> int:
      citations.sort(reverse=True)
      n = len(citations)
      for i in range(n, 0, -1):
        if citations[i - 1] >= i:
          return i
      return 0

Go 代码

func hIndex(citations []int) int {
  sort.Slice(citations, func(i, j int) bool {
    return citations[i] > citations[j]
  })
  for i := len(citations); i > 0; i -- {
    if citations[i - 1] >= i {
      return i
    }
  }
  return 0
}

Merge Sorted Array

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

88. 合并两个有序数组

分析

核心思路：从后往前双指针合并

由于 nums1 后面有足够的空间，可以从后往前填充最大元素，避免频繁移动数据
使用双指针分别指向两个数组的末尾，逐步比较并将较大的数放到 nums1 的最后

初始化指针：
- i = m - 1 ：指向 nums1 有效部分的末尾
- j = n - 1 ：指向 nums2 的末尾
- k = m + n - 1 ：指向 nums1 的末尾（总长度）
双指针比较：
- 比较 nums1[i] 和 nums2[j]，将较大值放到 nums1[k]，然后指针向前移动
处理剩余元素：
- 如果 nums2 还有剩余元素，继续填充到 nums1 中（nums1 剩下的部分已经是有序的，无需处理）

复杂度分析

时间复杂度：O(m + n)
空间复杂度：O(1)

C++代码

class Solution
{
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n)
    {
        int i = m - 1;         // 指向 nums1 有效部分的末尾
        int j = n - 1;         // 指向 nums2 的末尾
        int k = m + n - 1;     // 指向合并后 nums1 的末尾

        // 从后往前比较，填充较大元素
        while (i >= 0 && j >= 0)
            if (nums1[i] >= nums2[j])
                nums1[k--] = nums1[i--];  // nums1 较大，放到末尾
            else
                nums1[k--] = nums2[j--];  // nums2 较大，放到末尾

        // 如果 nums2 还有剩余元素，继续填充
        while (j >= 0)
            nums1[k--] = nums2[j--];
    }
};

Python 代码

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        i, j, k = m - 1, n - 1, n + m - 1

        while i >= 0 and j >= 0:
          if nums1[i] < nums2[j]:
            nums1[k] = nums2[j]
            j -= 1
          else:
            nums1[k] = nums1[i]
            i -= 1
          k -= 1

        while j >= 0:
          nums1[k] = nums2[j]
          j -= 1
          k -= 1

Go 代码

func merge(nums1 []int, m int, nums2 []int, n int)  {
  i, j, k := m - 1, n - 1, n + m - 1

  for i >= 0 && j >= 0 {
    if nums1[i] < nums2[j] {
      nums1[k] = nums2[j]
      j --
    } else {
      nums1[k] = nums1[i]
      i --
    }
    k --
  }

  for j >= 0 {
    nums1[k] = nums2[j]
    j --
    k --
  }
}

JavaScript 代码

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
var merge = function (nums1, m, nums2, n) {
  let i = m - 1,
    j = n - 1,
    k = n + m - 1;

  while (i >= 0 && j >= 0) {
    if (nums1[i] < nums2[j]) {
      nums1[k--] = nums2[j--];
    } else {
      nums1[k--] = nums1[i--];
    }
  }

  while (j >= 0) {
    nums1[k--] = nums2[j--];
  }
};

Minimum Number Of Arrows To Burst Balloons

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

452. 用最少数量的箭引爆气球

算法

要保证最少的弓箭数，我们可以采用如下贪心策略：
- 按区间的结束点升序排序：优先处理结束点较小的区间，这样可以最大化覆盖更多的区间
- 每次发射箭时，记录当前箭能够覆盖的结束点 r 。如果后续某个气球的开始点 x_start 大于当前箭的覆盖范围 r，则需要发射一支新的箭

将所有气球的直径区间按照结束点升序排序
初始化箭的数量 res 为 1，并将第一支箭的覆盖范围设为第一个区间的结束点
遍历排序后的区间：
- 如果当前区间的开始点大于箭的覆盖范围，说明需要一支新的箭来覆盖当前气球
- 更新箭的覆盖范围为当前区间的结束点

复杂度分析

排序的时间复杂度为 O(nlogn)，其中 n 是气球的数量；遍历区间的复杂度为 O(n)；总时间复杂度为 O(nlogn)
空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int findMinArrowShots(vector<vector<int>>& points)
    {
        // 如果没有气球，返回 0
        if (points.empty())
            return 0;

        // 按区间结束点升序排序
        std::sort(points.begin(), points.end(), [](std::vector<int> a, std::vector<int> b) {
            return a[1] < b[1];
        });

        // 初始化箭的数量和当前箭的覆盖范围
        int res = 1; // 至少需要一支箭
        int r = points[0][1]; // 第一支箭的覆盖范围

        // 遍历剩余的区间
        for (int i = 1; i < points.size(); ++i)
        {
            // 如果当前区间的起始点在当前箭的覆盖范围之外
            if (r < points[i][0])
            {
                ++res; // 增加一支箭
                r = points[i][1]; // 更新箭的覆盖范围
            }
        }

        return res;
    }
};

Python 代码

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
      points.sort(key = lambda point: point[1])
      res, r = 1, points[0][1]
      for i in range(1, len(points)):
        if r < points[i][0]:
          r = points[i][1]
          res += 1
      return res

Go 代码

import "sort"

func findMinArrowShots(points [][]int) int {
  sort.Slice(points, func(i, j int) bool {
    return points[i][1] < points[j][1]
  })
  res, r := 1, points[0][1]
  for i := 1; i < len(points); i += 1 {
    if r < points[i][0] {
      r = points[i][1]
      res += 1
    }
  }
  return res
}

Non Overlapping Intervals

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

435. 无重叠区间

分析

要保证最多的不重叠区间数，可以采用如下贪心策略：
- 按区间的结束点升序排序：结束点越早，剩余空间越多，更容易为后续区间预留空间
- 遍历排序后的区间，选择与前一个区间不重叠的区间，将其加入到保留的集合中

先按结束点排序。
初始化计数变量 count，记录当前不wq重叠区间的数量，初始值为 1
遍历排序后的区间：
- 如果当前区间的起始点 start 不小于上一个保留区间的结束点 cur，说明它与前面的区间不重叠，更新 cur 并增加计数
最后，用总区间数减去 count 即为需要移除的区间数

时间复杂度

排序的时间复杂度为 O(nlogn) ，其中 n 是区间的数量
遍历区间的复杂度为 O(n)

总时间复杂度为 O(nlogn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals)
    {
        // 如果没有区间，直接返回 0
        if (intervals.empty())
            return 0;

        // 按区间的结束点升序排序
        std::sort(intervals.begin(), intervals.end(), [](std::vector<int> a, std::vector<int> b) {
            return a[1] < b[1];
        });

        // 初始化计数器和当前区间结束点
        int count = 1; // 至少有一个区间不重叠
        int cur = intervals[0][1];

        // 遍历剩余的区间
        for (int i = 1; i < intervals.size(); ++i)
        {
            // 如果当前区间不重叠，则更新结束点并增加计数
            if (cur <= intervals[i][0])
            {
                ++count;
                cur = intervals[i][1];
            }
        }

        // 总区间数 - 不重叠区间数 = 需要移除的区间数
        return intervals.size() - count;
    }
};

Online Stock Span

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

901. 股票价格跨度

分析

维护单调递减栈：
- 栈中存储之前的股票价格以及对应的日期索引
- 保证栈中从栈底到栈顶的股票价格递减。这样可以快速找到比当前价格大的最近日期
核心操作：
- 对于当前股价 price：
  - 不断弹出栈顶元素，直到栈顶价格大于当前价格
  - 此时栈顶对应的索引即为最近一个比当前价格高的日期
- 当前跨度为：当前日期索引减去栈顶索引
边界处理：
- 初始化时，将一个虚拟价格（如 10^6 ）和一个虚拟日期（如 -1）入栈，方便处理第一天的数据

时间复杂度

每个价格最多会被栈操作一次（入栈和出栈各一次），因此所有操作的总时间复杂度为 O(n) ，每次调用 next 的均摊时间复杂度为 O(1)

空间复杂度

空间复杂度为 O(n)

C++代码

class StockSpanner
{
public:
    std::stack<int> prices; // 单调栈存储股票价格
    std::stack<int> day;    // 单调栈存储对应的日期索引
    int cur = 0;            // 当前的日期索引

    StockSpanner()
    {
        // 初始化栈：存入虚拟的最大价格和虚拟日期
        prices.push(1e6);
        day.push(-1);
    }

    int next(int price)
    {
        // 弹出所有小于等于当前价格的栈顶元素
        while (prices.top() <= price)
        {
            prices.pop();
            day.pop();
        }

        // 计算跨度：当前日期索引减去栈顶索引
        int res = cur - day.top();

        // 将当前价格和索引入栈
        prices.push(price);
        day.push(cur++);

        return res;
    }
};

Count Bits

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

338. 比特位计数

分析

状态定义
- 定义 f[i]：表示数字 i 的二进制表示中 1 的个数
状态转移
- 将数字 i 右移一位（即 i >> 1 ），相当于去掉最低位的二进制位
- 数字 i 中的 1 的个数可以表示为：f[i] = f[i >> 1] + (i & 1)
- f[i >> 1] ：前一个数字中 1 的个数
- i & 1：判断最低位是否为 1（若最低位为 1 ，加 1 ；否则加 0 ）
初始状态
- f[0] = 0 ：数字 0 的二进制表示中没有 1

时间复杂度

遍历从 1 到 n 的所有数字，动态规划计算 f[i]
每次计算的复杂度为 O(1) ，总复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> countBits(int n)
    {
        // 定义结果数组，长度为 n + 1
        std::vector<int> f(n + 1);
        // 动态规划填充数组
        for (int i = 1; i <= n; ++i)
            // 根据状态转移方程计算
            f[i] = f[i >> 1] + (i & 1);
        return f;
    }
};

Minimum Flips To Make A or B Equal to C

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

1318. 或运算的最小翻转次数

分析

位运算分析
- 对每一位（从低位到高位）分别判断 a 、b 、c 的二进制表示：
- x = a >> i & 1：表示 a 的第 i 位
- y = b >> i & 1：表示 b 的第 i 位
- z = c >> i & 1：表示 c 的第 i 位
根据 z 的值，分情况讨论：
- 如果 z = 0 ：
  - 需要 x = 0 且 y = 0，因此：需要翻转的次数 = x + y
- 如果 z = 1 ：
  - 至少需要 x = 1 或 y = 1 。若 x = 0 且 y = 0 ，则需要翻转 1
循环计算

逐位处理 a 、b 和 c ，根据上述规则累加所需的翻转次数

终止条件

由于题目限制 a, b, c 小于 1e9，其最大值在 2^30 以内，因此只需处理前 30 位即可

时间复杂度

O(1)

空间复杂度

O(1)

C++代码

class Solution
{
public:
    int minFlips(int a, int b, int c)
    {
        int res = 0;
        // 遍历 30 位
        for (int i = 0; i < 30; ++i)
        {
            int x = a >> i & 1; // a 的第 i 位
            int y = b >> i & 1; // b 的第 i 位
            int z = c >> i & 1; // c 的第 i 位

            if (z == 0)  // 如果 z 为 0
                res += x + y; // 需要翻转 x 和 y 中的所有 1
            else if (!x && !y) // 如果 z 为 1 且 x 和 y 都为 0
                ++ res; // 至少需要翻转一个 0 为 1
        }
        return res; // 返回总翻转次数
    }
};

Search Suggestions System

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

1268. 搜索推荐系统

分析

排序产品数组
- 为了能够快速按字典序找到前缀匹配的产品，首先对 products 按字典序排序
前缀匹配
- 对 searchWord 的每个前缀：
  - 使用一个变量 cur 保存当前前缀（即累加输入的字母）
  - 使用一个指针 k 维护当前搜索范围的起点。对于排序后的数组，可以跳过所有小于 cur 的字符串，加速搜索。
  - 遍历从 k 开始的最多三个字符串，检查它们是否以 cur 为前缀，若满足条件则加入推荐结果
提前结束
- 对于排序后的数组，如果某个字符串不再满足当前前缀条件，后续的字符串也不可能满足，可以提前结束内层循环

时间复杂度

排序：O(mlogm)，其中 m 是 products 的长度
前缀匹配：对于 searchWord 的每个字符，我们最多遍历 products 中 3 个字符串，复杂度为 O(n * avgLen)，其中 n 是 searchWord 的长度，avgLen 是产品的平均长度

总复杂度：O(mlogm + n * avgLen

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord)
    {
        // 结果数组
        std::vector<std::vector<std::string>> res;

        // 按字典序排序产品数组
        std::sort(products.begin(), products.end());

        // 当前前缀和产品数组的起点指针
        std::string cur;
        int n = products.size(), k = 0;

        // 遍历 searchWord 的每个字母
        for (char c : searchWord)
        {
            cur += c; // 更新当前前缀

            // 移动指针 k 跳过所有小于当前前缀的字符串
            while (k < n && products[k] < cur)
                ++k;

            // 收集符合条件的最多三个产品
            std::vector<std::string> tmp;
            for (int i = k; i < n && i < k + 3; ++i)
            {
                // 判断当前字符串是否以 cur 为前缀
                if (products[i].substr(0, cur.size()) == cur)
                    tmp.push_back(products[i]);
                else
                    break; // 剪枝：后续字符串不会匹配，提前退出
            }

            // 将当前前缀的推荐结果加入结果数组
            res.push_back(tmp);
        }
        return res;
    }
};

Best Time to Buy and Sell Stock With Transaction Fee

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

714. 买卖股票的最佳时机含手续费

分析

状态定义
- 定义 f[i][0] ：表示第 i 天结束时，手中没有持有股票的最大利润
- 定义 f[i][1] ：表示第 i 天结束时，手中持有股票的最大利润
状态转移
- 在第 i 天，可以有以下两种状态转移：
- 手中没有股票：
  - 可能来自前一天也没有股票，即 f[i-1][0]
  - 或者今天卖出股票，产生利润 f[i-1][1] + prices[i-1] - fee（卖出价格减去手续费）。
  - 转移公式：f[i][0] = max(f[i-1][0], f[i-1][1] + prices[i-1] - fee)
- 手中持有股票：
  - 可能来自前一天也持有股票，即 f[i-1][1]
  - 或者今天买入股票，产生利润 f[i-1][0] - prices[i-1]
  - 转移公式：f[i][1] = max(f[i-1][1], f[i-1][0] - prices[i-1])
初始状态
- 第 0 天没有股票：f[0][0] = 0（没有任何利润）
结果
- 最后一天手中没有股票的最大利润 f[n][0]

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int maxProfit(vector<int>& prices, int fee)
    {
        int n = prices.size(), INF = 0x3f3f3f3f;
        // 动态规划数组，初始化为负无穷（表示无效状态）
        std::vector<std::vector<int>> f(n + 1, std::vector<int>(2, -INF));
        f[0][0] = 0; // 第 0 天未持有股票的利润为 0
        int res = 0; // 最大利润

        for (int i = 1; i <= n; ++i)
        {
            // 第 i 天未持有股票的最大利润
            f[i][0] = std::max(f[i - 1][0], f[i - 1][1] + prices[i - 1] - fee);
            // 第 i 天持有股票的最大利润
            f[i][1] = std::max(f[i - 1][1], f[i - 1][0] - prices[i - 1]);
            // 更新最大利润
            res = std::max(res, f[i][0]);
        }
        return res;
    }
};

Domino And Tromino Tiling

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

790. 多米诺和托米诺平铺

分析

状态表示：
- 用 f[i][j] 表示覆盖 2 * i 面板且第i列状态为 j 的方法数。这里的状态 j 表示第 i 列的覆盖情况，具体含义如下：
  - j = 0 ：第 i 列已完全覆盖
  - j = 1 ：第 i 列的上方未覆盖，下方已覆盖
  - j = 2 ：第 i 列的下方未覆盖，上方已覆盖
  - j = 3 ：第 i 列完全未覆盖
状态转移：
- 从第 i-1 列的状态 j 转移到第 i 列的状态 k 。需要考虑瓷砖的放置规则，以及状态变化的可行性
- 定义 w[j][k] 为从状态 j 转移到状态 k 的合法性：
  - w[j][k] = 1 ：表示可以从 j 转移到 k
  - w[j][k] = 0 ：表示不可以从 j 转移到 k
初始状态：
- f[0][0] = 1 ：初始时第 0 列完全覆盖
- 其他状态初始化为 0。
目标：
- 返回 f[n][0]，即第 n 列完全覆盖的方案数

时间复杂度

外层遍历列数 n ，内层枚举状态 j 和 k 各为常数 4 ，因此时间复杂度为 O(16n) = O(n)

空间复杂度

O(n)

C++代码

class Solution
{
public:
    int numTilings(int n)
    {
        const int MOD = 1e9 + 7;

        // 转移矩阵，定义状态转移规则
        int w[4][4] = {
            {1, 1, 1, 1},
            {0, 0, 1, 1},
            {0, 1, 0, 1},
            {1, 0, 0, 0}
        };

        // 动态规划数组，f[i][j] 表示覆盖到第 i 列状态为 j 的方法数
        vector<vector<int>> f(n + 1, vector<int>(4));

        // 初始状态：第 0 列完全覆盖
        f[0][0] = 1;

        // 动态规划求解
        for (int i = 0; i < n; i++)
            for (int j = 0; j < 4; j++)
                for (int k = 0; k < 4; k++)
                    // 如果状态 j 可以转移到状态 k，则更新 f[i+1][k]
                    f[i + 1][k] = (f[i + 1][k] + f[i][j] * w[j][k]) % MOD;

        // 返回最终结果：覆盖到第 n 列且状态为 0 的方法数
        return f[n][0];
    }
};

Combination Sum III

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

216. 组合总和III

分析

采用深度优先搜索（DFS）+ 回溯来解决问题：

递归函数设计：
- 参数：
  - 当前搜索起点 start（避免重复选择数字）
  - 当前目标和 n
  - 当前还需要选的数字个数 k
- 终止条件：
  - 如果 n == 0 且 k == 0 ，说明找到了一组符合条件的组合，将其加入结果列表
  - 如果 n != 0 且 k == 0 ，或者 n < 0 ，直接返回（剪枝）
递归遍历：
- 从 start 开始，依次尝试数字 i （范围 start 到 9
- 每次选择 i 后递归：将 i 加入路径，更新 n = n - i ，更新 k = k - 1
- 递归返回后撤销选择 i（回溯）
剪枝优化：
- 如果 i > n ，则跳过剩余数字，直接剪枝，因为后续数字只会更大

时间复杂度

最多有 9 / k 个组合，其中 n / k = n! / k!(n-k)!
每次递归需要 O(k) 的时间来复制路径

总时间复杂度为 O(k * 9 / k)

空间复杂度

路径 path 的最大深度为 k ，递归调用栈的深度也为 k

空间复杂度为 O(k)

C++代码

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

    vector<vector<int>> combinationSum3(int k, int n)
    {
        dfs(1, n, k); // 从数字1开始搜索
        return res;
    }

    void dfs(int start, int n, int k)
    {
        if (n == 0)
        {
            if (k == 0)
                res.push_back(path); // 找到一个合法组合
            return;
        }
        if (k == 0) return; // 数字用完，但和未达到目标

        for (int i = start; i <= 9; ++i)
        {
            if (i > n) break; // 剪枝：当前数字大于目标和
            path.push_back(i); // 选择数字i
            dfs(i + 1, n - i, k - 1); // 递归搜索
            path.pop_back(); // 回溯，撤销选择
        }
    }
};

Koko Eating Bananas

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

875. 爱吃香蕉的珂珂

分析

定义区间：
- 吃香蕉速度的下界 l 为 1（最低速度）
- 吃香蕉速度的上界 r 为 10^9（最大速度，假设所有香蕉都在一堆中且时间充足）
判断函数 getTime(piles, k) ：
- 计算以速度 k 吃完所有香蕉需要的时间
- 遍历每堆香蕉 pile ，需要的时间为 pile / k 上取整，可以通过 (pile + k - 1) / k 实现
二分查找：
- 计算中间值 mid = (l + r) / 2 ：
  - 如果 getTime(piles, mid) <= h ，说明速度 mid 可以满足要求，但可能还有更小的速度满足条件，因此缩小上界 r = mid
  - 如果 getTime(piles, mid)} > h ，说明速度 mid 不够快，需要增大速度，更新下界 l = mid + 1
结束条件：
- 当 l == r 时，搜索范围缩小到单一值，返回 l 或 r 即为最小速度

时间复杂度

二分查找最多进行 O(log(10^9)) 次
每次计算 getTime(piles, k) 需要 O(n)，其中 n 是香蕉堆的数量

总复杂度为 O(n * log(10^9))

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
             {
public:
    // 判断以速度 k 吃完所有香蕉需要的时间
    int getTime(std::vector<int>& piles, int k)
    {
        int res = 0;
        for (int pile : piles)
            res += (pile + k - 1) / k; // 等价于 ceil(pile / k)
        return res;
    }

    int minEatingSpeed(vector<int>& piles, int h)
    {
        int l = 1, r = 1e9; // 定义速度的搜索区间
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (getTime(piles, mid) <= h) // 如果当前速度满足条件
                r = mid; // 尝试更小的速度
            else
                l = mid + 1; // 增大速度
        }
        return r; // 返回最小速度
    }
};

Min Cost Climbing Stairs

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

746. 使用最小花费爬楼梯

分析

状态定义：
- 定义 f[i] 为到达第 i 个台阶的最低花费
状态转移：
- 每次可以从前一个台阶爬上来，也可以从前两个台阶爬上来，选择花费较小的一种：f[i] = min(f[i-1] + cost[i-1], f[i-2] + cost[i-2])
初始状态：
- f[0] = 0 ：第 0 台阶为起点，不需要任何花费
- f[1] = 0 ：第 1 台阶为起点，也不需要任何花费
目标：
- 返回 f[n] ，即爬到楼梯顶部的最小花费

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int minCostClimbingStairs(vector<int>& cost)
    {
        int n = cost.size();
        std::vector<int> f(n + 1); // DP 数组，大小为 n+1

        // 从第 2 个台阶开始计算最低花费
        for (int i = 2; i <= n; ++i)
            f[i] = std::min(f[i - 1] + cost[i - 1], f[i - 2] + cost[i - 2]);

        return f[n]; // 返回到达顶部的最小花费
    }
};

Nth Tribonacci Number

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

1137. 第N个泰波那契数

分析

状态转移：
- 当前值 T_n 由前三项的值 T_{n-1}、T_{n-2}、T_{n-3} 相加得出
初始化：
- a 表示 T_{n-3}
- b 表示 T_{n-2}
- c 表示 T_{n-1}
- 初始值为 a = 0、b = 1、c = 1
迭代计算：
- 按照递推公式依次计算 T_3 到 T_n，并更新 a、b、c 的值
返回结果：
- 经过 n 次迭代后，a 存储的就是第 n 个泰波那契数

时间复杂度

计算第 n 个泰波那契数需要迭代 n 次，每次计算仅涉及常数操作

时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int tribonacci(int n)
    {
        int a = 0, b = 1, c = 1; // 初始化 T0, T1, T2
        while (n--) // 循环 n 次，计算第 n 个泰波那契数
        {
            long long d = (long long)a + b + c; // 计算当前值
            a = b; // 更新 T(n-3) 为 T(n-2)
            b = c; // 更新 T(n-2) 为 T(n-1)
            c = d; // 更新 T(n-1) 为 T(n)
        }
        return a; // 返回结果
    }
};

Find Peak Element

Sun, 05 Jan 2025 00:00:00 +0000

162. 寻找峰值

分析

定义区间：
- 使用两个指针 l 和 r，分别指向数组的起点和终点，表示当前搜索的范围
二分查找：
- 计算中间位置 mid = (l + r) / 2
- 比较 nums[mid] 和 nums[mid + 1] ：
  - 如果 nums[mid] > nums[mid + 1] ：说明峰值可能在左侧（包括当前 mid），将右边界 r 移到 mid
  - 如果 nums[mid] < nums[mid + 1] ：说明峰值可能在右侧，更新左边界 l 为 mid + 1
结束条件：
- 当 l == r 时，区间缩小为一个位置，此时该位置即为峰值索引

时间复杂度

时间复杂度 O(logn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int findPeakElement(vector<int>& nums)
    {
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = (l + r) >> 1;
            if (nums[mid] > nums[mid + 1])
                r = mid; // 峰值在左侧或当前 mid
            else
                l = mid + 1; // 峰值在右侧
        }
        return r; // 或返回 l，最终 l == r
    }
};

Guess Number Higher Or Lower

Sun, 05 Jan 2025 00:00:00 +0000

374. 猜数字大小

分析

初始化搜索范围：
- 定义变量 l 和 r 分别表示搜索范围的左右边界
- 初始搜索范围为 [1, n]
二分查找：
- 计算中间值 mid = (l + r) / 2，避免溢出可以写为 (l + r) >> 1
- 调用 guess(mid) 判断中间值与目标值的关系：
- 如果返回 -1，说明目标值更小，将右边界缩小为 r = mid
- 如果返回 1，说明目标值更大，将左边界缩小为 l = mid + 1
终止条件：
- 当左右边界相遇时，搜索结束，返回 r

时间复杂度

每次查找都会将搜索范围缩小一半，直到范围缩小到 1

时间复杂度为 O(logn)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int guessNumber(int n)
    {
        int l = 1, r = n; // 初始化左右边界
        while (l < r)
        {
            int mid = (long long)l + r >> 1; // 计算中间值
            if (guess(mid) <= 0) // 若目标值小于等于 mid
                r = mid; // 缩小右边界
            else // 若目标值大于 mid
                l = mid + 1; // 缩小左边界
        }
        return r; // 返回结果
    }
};

Successful Pairs Of Spells And Potions

Sun, 05 Jan 2025 00:00:00 +0000

2300. 咒语和药水的成功对数

分析

排序药水数组：
- 为了快速确定满足条件的药水，我们对药水数组 potions 进行升序排序
二分查找：
- 对于每个咒语 spells[i]，计算所需药水的最小能量值：target = (success + spells[i] - 1) / spells[i]
- 使用二分查找找到第一个大于等于 target 的药水位置 pos
- 满足条件的药水数量为 m - pos，其中 m 是药水数组的长度
返回结果：
- 对每个咒语计算成功组合的药水数量，并存储在结果数组 res 中

时间复杂度

药水数组排序：O(mlogm)
对每个咒语进行二分查找：O(nlogm)

总时间复杂度：O(mlogm + nlogm)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution {
public:
    // 二分查找：找到第一个大于等于 target 的药水位置
    int search(std::vector<int>& potions, long long target)
    {
        int l = 0, r = potions.size();
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (potions[mid] >= target)
                r = mid;
            else
                l = mid + 1;
        }
        return r;
    }

    vector<int> successfulPairs(vector<int>& spells, vector<int>& potions, long long success)
    {
        int n = spells.size(), m = potions.size();
        std::sort(potions.begin(), potions.end()); // 排序药水数组
        std::vector<int> res(n);
        for (int i = 0; i < n; ++i)
        {
            // 计算当前咒语的 target 值
            int pos = search(potions, (success + spells[i] - 1) / spells[i]);
            res[i] = m - pos; // 成功组合数量
        }
        return res;
    }
};

Maximum Subsequence Score

Sat, 04 Jan 2025 00:00:00 +0000

2542. 最大子序列的分数

分析

贪心策略：
- 优先选择 nums2 值较大的元素，以确保当前子序列的最小值较大，即 min(nums2) 尽可能大，进而最大化分数
降序排序：
- 将 nums2 和 nums1 的对应元素组合成一个二元组 nums2[i], nums1[i]，并按 nums2 降序排列，这样我们可以从最大值开始依次考虑子序列
优先队列维护和：
- 使用一个最小堆 min_heap 来动态维护当前选定子序列中 nums1 的 k 个元素的和
- 如果堆的大小超过 k，移除堆顶（即当前最小的元素），从而保持堆的大小不超过 k
- 这样可以保证始终以较大的元素尽量填满子序列
更新最大分数：
- 每当堆的大小达到 k ，更新最大分数

时间复杂度

排序操作：O(n \log n)，其中 n 是数组的长度
遍历 combine 并维护堆：O(nlogk)，每次插入或删除堆顶操作需要 O(logk)

总时间复杂度：O(nlogn + nlogk)

空间复杂度

使用了一个最小堆，大小为 O(k)
存储组合后的数组，空间为 O(n)

总空间复杂度：O(n + k)

C++代码

class Solution
{
public:
    long long maxScore(vector<int>& nums1, vector<int>& nums2, int k)
    {
        using PII = std::pair<int, int>;
        std::vector<PII> combine;

        // 将 nums1 和 nums2 的元素组合成二元组
        for (int i = 0; i < nums1.size(); ++i)
            combine.push_back({nums2[i], nums1[i]});

        // 按 nums2 降序排列
        std::sort(combine.rbegin(), combine.rend());

        long long nums1_sum = 0, max_score = 0;
        std::priority_queue<int, std::vector<int>, std::greater<int>> min_heap;

        // 遍历每个元素，维护一个大小为 k 的子序列
        for (auto t : combine)
        {
            int num2 = t.first, num1 = t.second;
            nums1_sum += num1;
            min_heap.push(num1);

            // 如果堆大小超过 k，则移除最小值
            if (min_heap.size() > k)
            {
                nums1_sum -= min_heap.top();
                min_heap.pop();
            }

            // 更新最大分数
            if (min_heap.size() == k)
                max_score = std::max(max_score, nums1_sum * num2);
        }

        return max_score;
    }
};

Smallest Number In Infinite Set

Sat, 04 Jan 2025 00:00:00 +0000

2336. 无限集中的最小数字

分析

使用有序集合 std::set 来维护集合 s，其特性是自动按升序排列元素：
- popSmallest() 可以通过获取集合中的第一个元素*s.begin() 来实现最小值的提取，时间复杂度为 O(log n)
- addBack(num) 通过插入操作，将数字加入集合，同时自动维护顺序，时间复杂度为 O(log n)
由于题目给出 1 <= num <= 1000，因此初始化集合时，可以预先将 s 初始化为 1 ~ 1000

时间复杂度

popSmallest()：
- 获取最小值 *s.begin(): O(1)
- 删除操作 s.erase(): O(\log n)
- 总时间复杂度：O(logn)
addBack(num)：
- 插入操作 s.insert()：O(logn)
初始化操作：插入 n 个初始值：总复杂度为 O(nlogn)

空间复杂度

主要存储集合 s，大小为集合中的元素个数，空间复杂度为 O(n)

C++代码

class SmallestInfiniteSet
{
public:
    std::set<int> s;

    // 构造函数，初始化集合
    SmallestInfiniteSet()
    {
        // 集合的初始值为 [1, 2, ..., 1000]
        for (int i = 1; i <= 1000; ++i)
            s.insert(i);
    }

    // 移除并返回最小值
    int popSmallest()
    {
        // 获取集合中最小值
        int t = *s.begin();
        // 从集合中删除最小值
        s.erase(s.begin());
        return t;
    }

    // 将数字添加回集合
    void addBack(int num)
    {
        // 插入数字，std::set 会自动去重
        s.insert(num);
    }
};

Total Cost To Hire K Workers

Sat, 04 Jan 2025 00:00:00 +0000

2462. 雇佣k位工人的总代价

分析

双端选择策略：
- 使用两个最小堆分别管理两端候选工人的代价：
  - 左堆 left_heap：存储前 candidates 个工人
  - 右堆 right_heap：存储后 candidates 个工人
- 每轮从两堆中选择代价最小的工人。如果代价相同，优先选择左堆的工人（即下标较小的工人）
动态维护候选集合：
- 每次从堆中弹出一个工人后：
  - 如果是左堆弹出，在左堆加入新的候选工人（如果剩余工人足够）
    - 如果是右堆弹出，在右堆加入新的候选工人（如果剩余工人足够）
模拟雇佣过程：
- 进行 k 轮雇佣，每轮计算当前最小代价并累加到总成本

时间复杂度

初始化堆：最多处理 2 * candidates 个工人，复杂度为 O(candidates * log candidates)
每次雇佣需要从堆中弹出元素并可能插入一个新元素，复杂度为 O(log candidates)
总共雇佣 k 轮，因此雇佣过程的复杂度为 O(k * log candidates)

总时间复杂度：O((k + candidates) * log candidates)

空间复杂度

使用两个最小堆，每个堆最多存储 candidates 个元素

总空间复杂度：O(candidates)

C++代码

class Solution
{
public:
    long long totalCost(vector<int>& costs, int k, int candidates)
    {
        // 左、右堆分别维护前 candidates 和后 candidates 个工人的代价
        std::priority_queue<int, std::vector<int>, std::greater<int>> left_heap, right_heap;
        int l = 0, r = costs.size() - 1;

        // 初始化左堆
        for (int i = 0; i < candidates && l <= r; ++i, ++l)
            left_heap.push(costs[l]);
        // 初始化右堆
        for (int i = 0; i < candidates && l <= r; ++i, --r)
            right_heap.push(costs[r]);

        long long totalCost = 0; // 总代价
        for (int i = 0; i < k; ++i)
        {
            // 从两堆中选择代价最小的工人
            if (left_heap.size() && (right_heap.empty() || left_heap.top() <= right_heap.top()))
            {
                totalCost += left_heap.top();  // 累加代价
                left_heap.pop();              // 移除工人
                if (l <= r)                   // 更新左堆
                    left_heap.push(costs[l++]);
            }
            else
            {
                totalCost += right_heap.top(); // 累加代价
                right_heap.pop();              // 移除工人
                if (l <= r)                    // 更新右堆
                    right_heap.push(costs[r--]);
            }
        }

        return totalCost; // 返回总代价
    }
};

Evaluate Division

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

399. 除法求值

分析

构建图：
- 遍历 equations 和 values，构建邻接表表示的加权有向图 graph
- 如果 A / B = v，则添加边 A -> B 和 B -> A
Floyd-Warshall 算法：
- 利用三重循环，尝试通过任意中间节点 k 更新任意两节点 i 和 j 间的比值
- 如果 i -> k 和 k -> j 的路径存在，则更新 i -> j 的权重为 graph[i][k] * graph[k][j]
处理查询：
- 对于每个查询 [C, D]：
  - 如果 C 和 D 不在图中，或者两者之间无路径，则返回 -1.0
  - 否则返回图中存储的 C -> D 的权重

时间复杂度

构建图：遍历 equations，时间复杂度为 O(E)，其中 E 是等式的数量
Floyd-Warshall 算法：三重循环，时间复杂度为 O(V^3)，其中 V 是变量的数量
处理查询：遍历 queries，时间复杂度为 O(Q)，其中 Q 是查询的数量

总体时间复杂度为 O(V^3 + E + Q)

空间复杂度

总的空间复杂度为 O(V^2 + Q)

C++代码

class Solution {
public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries)
    {
        // 构建图
        std::unordered_map<std::string, std::unordered_map<std::string, double>> graph;
        std::unordered_set<std::string> variables;
        for (int i = 0; i < equations.size(); ++i)
        {
            std::string A = equations[i][0], B = equations[i][1];
            variables.insert(A);
            variables.insert(B);
            graph[A][B] = values[i];         // A / B = values[i]
            graph[B][A] = 1 / values[i];     // B / A = 1 / values[i]
        }

        // Floyd-Warshall算法：更新所有节点对的路径比值
        for (std::string k : variables)
            for (std::string i : variables)
                for (std::string j : variables)
                    if (graph[i][k] && graph[k][j]) // 如果 i->k 和 k->j 存在路径
                        graph[i][j] = graph[i][k] * graph[k][j];

        // 处理查询
        std::vector<double> res;
        for (auto query : queries)
        {
            std::string A = query[0], B = query[1];
            if (graph[A][B])  // 如果 A->B 存在路径
                res.push_back(graph[A][B]);
            else
                res.push_back(-1.0);  // 不存在路径
        }
        return res;
    }
};

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; // 无法找到出口
    }
};

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;  // 返回需要变更方向的最小数目
    }
};

Delete Node In a BST

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

450. 删除二叉搜索树中的节点

分析

节点为叶子节点：
- 如果删除的节点没有子节点，直接将其置为 nullptr
节点只有一个子节点：如果删除的节点只有左子树或右子树，则将左子树或右子树上提
节点有两个子节点：
- 在这种情况下，删除节点无法直接处理。需要找到节点的后继节点（右子树中最小的节点）
- 找到右子树中的最小节点，将其值赋给当前删除节点，然后递归删除该后继节点（变为第二种情况）

时间复杂度

最坏情况下，树的高度为 O(h)，需要进行递归查找和删除节点操作，因此时间复杂度为 O(h)

对于平衡的二叉搜索树，时间复杂度为 O(log n)；对于退化为链表的情况，时间复杂度为 O(n)

空间复杂度

递归栈的空间复杂度为 O(h)，其中 h 是树的高度。对于平衡二叉搜索树，空间复杂度为 O(log n)；对于退化为链表的情况，空间复杂度为 O(n)

C++代码

class Solution {
public:

    // 主函数，调用删除逻辑并返回根节点
    TreeNode* deleteNode(TreeNode* root, int key)
    {
      del(root, key);  // 调用删除操作
      return root;     // 返回更新后的根节点
    }

    // 辅助函数：递归删除节点
    void del(TreeNode* &root, int key)
    {
      if (!root)  // 如果节点为空，直接返回
        return;

      // 根据 key 和当前节点值的大小关系决定递归方向
      if (root->val > key)
        del(root->left, key);  // 在左子树中查找
      else if (root->val < key)
        del(root->right, key); // 在右子树中查找
      else  // 找到目标节点
      {
        // 情况 1：节点没有子节点，直接删除
        if (!root->left && !root->right)
          root = nullptr;

        // 情况 2：节点只有右子树
        else if (!root->left)
          root = root->right;

        // 情况 3：节点只有左子树
        else if (!root->right)
          root = root->left;

        // 情况 4：节点有两个子树
        else
        {
          // 找右子树中最小的节点（后继节点）
          TreeNode* p = root->right;
          while (p->left)
            p = p->left;

          // 将后继节点的值赋给当前节点
          root->val = p->val;

          // 删除后继节点
          del(root->right, p->val);
        }
      }
    }
};

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; // 当前方向为右
    }
};

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;              // 返回层号
    }
};

Search In a Binary Search Tree

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

700. 二叉搜索树中的搜索

分析

递归查找：
- 如果当前节点为空，返回 null，表示未找到目标节点
- 如果当前节点的值等于目标值 val，返回该节点
- 如果当前节点的值大于 val，递归查找其左子树
- 如果当前节点的值小于 val，递归查找其右子树
返回结果：
- 如果找到目标节点，返回其为根的子树
- 如果未找到目标节点，返回 null

时间复杂度

最坏情况下为树的高度 O(h)，其中 h 是树的高度。对于平衡二叉搜索树，时间复杂度为 O(log n)

对于退化为链表的情况，时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(h)

C++代码

class Solution
{
public:
    TreeNode* searchBST(TreeNode* root, int val)
    {
      // 基本情况：当前节点为空，返回 nullptr
      if (!root)
        return nullptr;

      // 当前节点的值大于目标值，递归查找左子树
      if (root->val > val)
        return searchBST(root->left, val);

      // 当前节点的值小于目标值，递归查找右子树
      if (root->val < val)
        return searchBST(root->right, val);

      // 找到目标节点，返回该节点
      return root;
    }
};

Construct Binary Tree from Preorder and Inorder Traversal

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

105. 从前序与中序遍历序列构造二叉树

分析

用一个哈希表 pos 记录中序遍历中每个值的索引，方便快速查找
递归构造子树：
- 子树的根节点对应前序遍历的第一个节点
- 根据根节点在中序遍历中的位置，划分左右子树的前序和中序区间
- 分别递归构造左子树和右子树

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    std::unordered_map<int, int> pos; // 中序遍历中值到索引的映射

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
    {
        // 建立中序遍历的值索引映射，方便快速定位根节点位置
        for (int i = 0; i < inorder.size(); ++i)
            pos[inorder[i]] = i;

        // 调用递归构造函数
        return build(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
    }

    TreeNode* build(std::vector<int>& preorder, std::vector<int>& inorder, int pl, int pr, int il, int ir)
    {
        if (pl > pr) // 如果前序区间为空，返回空节点
            return nullptr;

        // 当前子树的根节点
        TreeNode* root = new TreeNode(preorder[pl]);

        // 根节点在中序遍历中的位置
        int k = pos[root->val];

        // 递归构造左子树
        root->left = build(preorder, inorder, pl + 1, pl + 1 + k - 1 - il, il, k - 1);

        // 递归构造右子树
        root->right = build(preorder, inorder, pl + 1 + k - 1 - il + 1, pr, k + 1, ir);

        return root;
    }
};

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;
        }
    }
};

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; // 返回右视图节点值
    }
};

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;
    }
};

Maximum Twin Sum of A Linked List

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

2130. 链表最大孪生和

分析

遍历链表：
- 第一次遍历链表计算长度 n
- 在第一次遍历的同时，将前 n/2 个节点的值压入栈中
计算孪生和：
- 从第 n/2 个节点开始，第二次遍历链表
- 弹出栈顶元素，与当前节点值相加计算孪生和，更新最大值
返回结果：
- 遍历完成后，返回最大孪生和

时间复杂度

计算长度：遍历链表一次，时间复杂度为 O(n)
计算孪生和：再次遍历后半部分链表，时间复杂度为 O(n/2)

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

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    int pairSum(ListNode* head)
    {
        // 栈用于存储前半部分链表节点的值
        std::stack<int> stk;

        // 第一次遍历计算链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 第二次遍历，将前半部分节点值压入栈中
        ListNode* p = head;
        for (int i = 0; i < len / 2; ++i)
        {
            stk.push(p->val);
            p = p->next;
        }

        // 计算最大孪生和
        int res = 0;
        while (p)
        {
            // 弹出栈顶值，与当前节点值相加
            res = std::max(res, p->val + stk.top());
            stk.pop();
            p = p->next;
        }

        return res;
    }
};

Odd Even Linked List

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

328. 奇偶链表

分析

特例处理：
- 如果链表为空，或只有一个节点，则无需操作，直接返回原链表
分离奇偶链表：
- 定义两个链表头指针：
  - odd_head：奇数节点的头指针，初始为 head
  - even_head：偶数节点的头指针，初始为 head->next
- 遍历链表：
  - 用 odd_tail 和 even_tail 分别维护奇数链表和偶数链表的尾节点
  - 根据节点的索引位置，交替更新奇数链表和偶数链表的尾节点
拼接奇偶链表：
- 将奇数链表的尾节点连接到偶数链表的头节点
- 将偶数链表的尾节点指向 nullptr
返回结果：
- 返回奇数链表的头节点 odd_head

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* oddEvenList(ListNode* head)
    {
        // 特例处理：链表为空或只有一个节点
        if (!head || !head->next)
            return head;

        // 初始化奇数链表和偶数链表的头尾指针
        ListNode *odd_head = head, *odd_tail = odd_head;
        ListNode *even_head = head->next, *even_tail = even_head;

        // 遍历链表，交替处理奇数节点和偶数节点
        for (ListNode* p = head->next->next; p;)
        {
            // 处理奇数节点
            odd_tail = odd_tail->next = p;
            p = p->next;

            // 处理偶数节点
            if (p)
            {
                even_tail = even_tail->next = p;
                p = p->next;
            }
        }

        // 拼接奇数链表和偶数链表
        odd_tail->next = even_head;
        even_tail->next = nullptr;

        return odd_head;
    }
};

Delete The Middle Node of A Linked List

Fri, 27 Dec 2024 00:00:00 +0000

2095. 删除链表的中间节点

分析

特例处理：
- 如果链表为空，直接返回 nullptr
- 如果链表只有一个节点，删除后返回 nullptr
- 如果链表只有两个节点，删除第二个节点，直接将 head->next 设为 nullptr
计算链表长度：
- 遍历链表，计算其长度 n
定位中间节点的前一个节点：
- 根据 n / 2 ，找到中间节点的前一个节点
- 将该节点的 next 指针指向中间节点的下一个节点，从而跳过中间节点
返回结果：
- 返回删除中间节点后的链表头节点

时间复杂度

计算链表长度：需要遍历链表一次，时间复杂度为 O(n)
定位中间节点的前一个节点：需要遍历链表一次，时间复杂度为 O(n)

总时间复杂度：O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    ListNode* deleteMiddle(ListNode* head)
    {
        // 如果链表只有一个节点
        if (!head->next)
            return nullptr;

        // 如果链表只有两个节点
        if (!head->next->next)
        {
            head->next = nullptr;
            return head;
        }

        // 计算链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 找到中间节点的前一个节点
        ListNode* p = head;
        for (int i = 0; i < len / 2 - 1; ++i)
            p = p->next;

        // 删除中间节点
        p->next = p->next->next;

        return head;
    }
};

Dota 2 Senate

Fri, 27 Dec 2024 00:00:00 +0000

649. Dota2参议院

分析

使用两个队列分别存储两派参议员的索引位置，模拟投票过程：

遍历输入字符串 senate：
- 将 'R' 的索引存入队列 r
- 将 'D' 的索引存入队列 d
模拟投票过程：
- 每轮从两个队列中各取出一个参议员的索引
- 索引较小的一方（出场顺序在前）可以禁言对方阵营的参议员，并将自己放回队列末尾，索引增加 n（表示其下一轮出场的顺序）
- 索引较大的参议员失去投票权，从队列中移除
重复上述过程，直到某一队列为空
判断结果：
- 如果 r 非空，返回 "Radiant"
- 如果 d 非空，返回 "Dire"

时间复杂度

初始化队列：O(n)，遍历字符串一次
模拟投票：每次至少移除一个参议员，最多进行 O(n) 次

总时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution {
public:
    string predictPartyVictory(string senate)
    {
        std::queue<int> r, d; // 分别存储两派参议员的索引
        int n = senate.size();

        // 初始化队列
        for (int i = 0; i < n; ++i)
            if (senate[i] == 'R')
                r.push(i);
            else
                d.push(i);

        // 模拟投票过程
        while (!r.empty() && !d.empty())
        {
            int r_index = r.front();
            int d_index = d.front();
            r.pop();
            d.pop();
            // 索引较小的参议员胜出，加入下一轮
            if (r_index < d_index)
                r.push(r_index + n); // Radiant 禁言 Dire
            else
                d.push(d_index + n); // Dire 禁言 Radiant
        }

        // 判断获胜阵营
        return r.empty() ? "Dire" : "Radiant";
    }
};

Number of Recent Calls

Fri, 27 Dec 2024 00:00:00 +0000

933. 最近的请求次数

分析

利用队列的先进先出特性来存储请求的时间点，并维护一个滑动窗口：

存储请求时间：
- 每次调用 ping(t)，将时间 t 加入队列
移除过期请求：
- 从队列头部开始检查，如果某个时间点不在 [t-3000, t] 范围内（即 t - q.front() > 3000），则将其从队列中移除
统计有效请求：
- 最后，队列的大小即为过去 3000 毫秒内的请求数量

时间复杂度

时间复杂度 O(1)

空间复杂度

空间复杂度为 O(n)

C++代码

class RecentCounter
{
public:
    std::queue<int> q; // 用于存储请求时间点的队列

    RecentCounter()
    {
        // 构造函数初始化，无需额外操作
    }

    int ping(int t)
    {
        q.push(t); // 将当前请求时间添加到队列
        // 移除不在 [t-3000, t] 范围内的请求
        while (t - q.front() > 3000)
            q.pop();
        return q.size(); // 返回队列大小，即为有效请求数
    }
};

Asteroid Collision

Thu, 26 Dec 2024 00:00:00 +0000

735. 小行星碰撞

分析

栈的意义：用一个栈 res 保存当前未爆炸的小行星。栈中元素表示这些小行星在当前状态下可以安全存在
碰撞处理逻辑：
- 遍历数组中的每颗小行星：
- 如果小行星向右移动（正数），直接将其加入栈中
- 如果小行星向左移动（负数），检查栈顶元素：
- 如果栈顶是向右移动的小行星且比当前小行星小（绝对值），栈顶小行星爆炸，当前小行星继续向左检测
- 如果栈顶是向右移动的小行星且与当前小行星大小相等，两者都爆炸
- 如果栈为空或栈顶为负数（同向移动），当前小行星直接入栈
最终状态：
- 遍历完成后，栈中的小行星即为剩下的未爆炸小行星

时间复杂度

每颗小行星最多入栈和出栈一次

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> asteroidCollision(vector<int>& asteroids)
    {
        std::vector<int> res; // 用作栈
        for (int x : asteroids)
        {
            if (x > 0)
                res.push_back(x); // 向右移动的小行星直接入栈
            else
            {
                // 检测栈顶的小行星是否与当前小行星碰撞
                while (res.size() && res.back() > 0 && res.back() < -x)
                    res.pop_back(); // 栈顶小行星爆炸
                // 检查是否当前小行星与栈顶大小相等
                if (res.size() && res.back() == -x)
                    res.pop_back(); // 两颗小行星同时爆炸
                // 栈为空或栈顶为负数，当前小行星入栈
                else if (res.empty() || res.back() < 0)
                    res.push_back(x);
            }
        }
        return res;
    }
};

Removing Stars from a String

Thu, 26 Dec 2024 00:00:00 +0000

2390. 从字符串中移除星号

分析

利用栈的性质：
- 遍历字符串 s，将每个字符逐个处理
- 如果遇到非星号字符，将其加入结果字符串 res 中（模拟入栈操作）
- 如果遇到星号 *，移除结果字符串 res 的最后一个字符（模拟出栈操作）
最终结果：
- 遍历完成后，结果字符串 res 即为移除所有星号及其左侧字符后的字符串

时间复杂度

每个字符只被处理一次

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
             {
public:
    string removeStars(string s)
    {
        std::string res; // 用作结果栈
        for (auto c : s)
        {
            if (c == '*')
                res.pop_back(); // 移除最后一个字符
            else
                res.push_back(c); // 添加当前字符
        }
        return res;
    }
};

Determine If Two Strings Are Close

Wed, 25 Dec 2024 00:00:00 +0000

1657. 确定两个字符串是否接近

分析

长度检查：
- 如果 word1 和 word2 的长度不同，则它们无法接近，直接返回 false
字符集合一致性检查：
- 两个字符串需要包含相同的字符集合。例如，word1 = "abc" 和 word2 = "bca" 包含的字符都是 {a, b, c}，可以进行字符交换；而 word1 = "abc" 和 word2 = "bcd" 的字符集合不同，不可能接近
频次匹配：
- 统计每个字符串中字符的频次，并将频次排序。若两个字符串的字符频次分布相同，则可以通过变换使其互相接近

时间复杂度

统计字符频次的时间为 O(n)，其中 n 是字符串的长度
排序频次数组的时间为 O(26log26)，常数级别可视为 O(1)

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    bool closeStrings(string word1, string word2)
    {
        // 如果长度不同，直接返回 false
        if (word1.size() != word2.size())
            return false;

        // 统计两个字符串中每个字符的频次
        std::vector<int> cnt1(26, 0);
        std::vector<int> cnt2(26, 0);
        for (int i = 0; i < word1.size(); ++i)
        {
            ++cnt1[word1[i] - 'a'];
            ++cnt2[word2[i] - 'a'];
        }

        // 检查两个字符串是否包含相同的字符集合
        for (int i = 0; i < 26; ++i)
        {
            if ((cnt1[i] && !cnt2[i]) || (!cnt1[i] && cnt2[i]))
                return false;
        }

        // 对频次数组排序并检查是否相同
        std::sort(cnt1.begin(), cnt1.end());
        std::sort(cnt2.begin(), cnt2.end());

        return cnt1 == cnt2;
    }
};

Equal Row and Column Pairs

Wed, 25 Dec 2024 00:00:00 +0000

2352. 相等行列对

分析

逐行逐列比较：
- 使用两层循环遍历矩阵，外层遍历行，内层遍历列
- 对每个行列对 (R_i, C_j)，检查对应元素是否相等
逐元素对比：
- 对行 R_i 和列 C_j 的每个元素进行对比，若所有元素均相等，则计数加 1
计数统计：
- 遍历结束后返回满足条件的行列对数量

时间复杂度

外层两层循环 O(n^2)，用于遍历所有行列对
内层循环 O(n)，用于比较行和列的元素

总时间复杂度为 O(n^3)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    int equalPairs(vector<vector<int>>& grid)
    {
        int n = grid.size();
        int res = 0;

        // 遍历每一行和每一列
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                int k = 0;

                // 对比行和列的每个元素
                while (k < n && grid[i][k] == grid[k][j])
                    ++k;

                // 如果行和列完全匹配
                if (k == n)
                    ++res;
            }
        }
        return res;
    }
};

Unique Number of Occurrences

Wed, 25 Dec 2024 00:00:00 +0000

1207. 独一无二的出现次数

分析

统计出现次数：
- 使用哈希表 cnt 统计数组中每个元素的出现次数，键为元素值，值为该元素的出现次数
判断次数是否唯一：
- 使用集合 hash 存储所有出现次数。
- 遍历哈希表 cnt，如果发现某次出现次数已存在于集合中，则返回 false
- 如果遍历结束后没有重复次数，返回 true

时间复杂度

统计元素出现次数的时间是 O(n)，其中 n 是数组的长度
检查次数唯一性的时间是 O(m)，其中 m 是数组中不同元素的个数

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

空间复杂度

空间复杂度为 O(m)

C++代码

class Solution
{
public:
    bool uniqueOccurrences(vector<int>& arr)
    {
        // 统计元素出现次数
        std::unordered_map<int, int> cnt;
        for (int x : arr)
            ++cnt[x];

        // 检查出现次数是否唯一
        std::unordered_set<int> hash;
        for (auto item : cnt)
        {
            // 如果某个次数已存在，返回 false
            if (hash.count(item.second))
                return false;
            hash.insert(item.second);
        }

        // 如果所有次数都唯一，返回 true
        return true;
    }
};

Find Pivot Index

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

724. 寻找数组的中心下标

分析

总和计算：
- 首先计算整个数组的总和 sum
逐个检查下标：
- 遍历数组，维护一个变量 s，记录当前位置左侧所有元素的和
- 判断当前下标是否满足条件：左侧和 s 是否等于右侧和 sum - s - nums[i]
- 如果条件满足，返回当前下标 i
- 否则，更新左侧和 s 为 s + nums[i]
无解处理：
- 如果遍历结束仍未找到符合条件的下标，返回 -1

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int pivotIndex(vector<int>& nums)
    {
        int sum = 0;
        for (int num : nums) // 计算数组总和
            sum += num;

        int s = 0; // 左侧和初始化为 0
        for (int i = 0; i < nums.size(); ++i)
        {
            // 判断当前下标是否满足条件
            if (s == sum - s - nums[i])
                return i;
            // 更新左侧和
            s += nums[i];
        }
        return -1; // 未找到中心下标
    }
};

Find The Difference Of Two Arrays

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

2215. 找出两数组的不同

分析

使用哈希集合存储唯一元素：
- 为了处理数组中重复的元素，我们使用两个集合 hash1 和 hash2 分别存储 nums1 和 nums2 的唯一值
查找差集：
- 遍历集合 hash1，找出不在 hash2 中的元素，存入 res[0]
- 遍历集合 hash2，找出不在 hash1 中的元素，存入 res[1]
返回结果：
- 返回结果列表 res，包含两个子列表

时间复杂度

遍历数组构建集合的时间是 O(n + m)
遍历集合查找差集的时间是 O(n + m)

总时间复杂度：O(n + m)，其中 n 和 m 分别是 nums1 和 nums2 的长度

空间复杂度

空间复杂度：O(u + v)，其中 u 和 v 是 nums1 和 nums2 中的不同元素个数

C++代码

class Solution {
public:
    vector<vector<int>> findDifference(vector<int>& nums1, vector<int>& nums2)
    {
        // 使用集合存储唯一元素
        std::unordered_set<int> hash1;
        std::unordered_set<int> hash2;

        // 将 nums1 的元素加入 hash1
        for (int num : nums1)
            hash1.insert(num);

        // 将 nums2 的元素加入 hash2
        for (int num : nums2)
            hash2.insert(num);

        std::vector<std::vector<int>> res(2);

        // 找出 nums1 中不在 nums2 中的元素
        for (int num : hash1)
            if (!hash2.count(num))
                res[0].push_back(num);

        // 找出 nums2 中不在 nums1 中的元素
        for (int num : hash2)
            if (!hash1.count(num))
                res[1].push_back(num);

        return res;
    }
};

Find The Highest Altitude

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

1732. 找到最高海拔

分析

初始海拔 h 为 0，最高海拔 res 也初始化为 0
遍历数组 gain：
- 累加当前海拔高度 h += g ，其中 g 为当前的海拔差
- 更新最高海拔 res = max(res, h)
遍历完成后，返回 res

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    int largestAltitude(vector<int>& gain)
    {
      int res = 0;
      int h = 0;
      for (int g : gain)
      {
        h += g;
        res = std::max(res, h);
      }
      return res;
    }
};