Elysium's Blog

串联所有单词的子串

Sun, 21 Sep 2025 00:00:00 GMT

分析

这道题和 438 题类似，都是利用滑动窗口来解决，思路也大抵一样。不过需要留意：438 题中是针对单个字符，而此题是针对整个字符串。因此， differ 也从一个数组变成了一个哈希表。我们令 n 为每个单词的长度， m 为数组 words 的长度， s_len 为字符串 s 的长度。因为我们要逐个对比字符串中的字符，所以可以用 $m \times n$ 来摊平需要比较的字符，用 i 作为偏移量比较对这些窗口逐个比对。因此，我们可以设置一个初始为 $0$ 的循环。结束条件为偏移量小于单词长度并小于等于窗口长度。随后，我们可以设置一个哈希表 differ。接下来的步骤和 438 题类似：先用 differ 统计第一个窗口中各个单词出现的次数。然后遍历 words 数组，减去 differ 中对应单词的计数。此时，differ 变成了「窗口与 words 差异」的统计。

现在让我们开始滑动窗口。用 start 表示窗口索引，步长为 $n$。接着我们可以套用 438 题的逻辑：

在窗口最左侧移除旧单词（differ[word]--）。
在窗口右侧加入新单词（differ[word]++）。
如果某个单词的计数为 $0$，那么删除它（differ.erase(word)）。

最后，如果 differ 为空，若为空，那么 start 就是一个答案，加入答案数组。

解答

class Solution {
public:
  vector<int> findSubstring(string s, vector<string> &words) {
    int m = words.size(), n = words[0].size(), s_len = s.size();
    vector<int> ans;

    for (auto i = 0; i < n && i + m * n <= s_len; ++i) {
      unordered_map<string, int> differ;
      for (auto j = 0; j < m; ++j)
        ++differ[s.substr(i + j * n, n)];

      for (auto &word : words)
        if (--differ[word] == 0)
          differ.erase(word);

      for (auto start = i; start < s_len - m * n + 1; start += n) {
        if (start != i) {
          auto word = s.substr(start - n, n);
          if (--differ[word] == 0)
            differ.erase(word);

          word = s.substr(start + (m - 1) * n, n);
          if (++differ[word] == 0)
            differ.erase(word);
        }

        if (differ.empty())
          ans.emplace_back(start);
      }
    }

    return ans;
  }
};

找到字符串中所有字母异位词

Sat, 20 Sep 2025 00:00:00 GMT

分析

这道题是适合使用滑动窗口来解决。一开始，我们可以先比较字符串 s 和 p 的长度。当 s.length() < p.length() 时，直接返回空数组。接下来，我们可以定义两个长度为26的数组 s_count[] 和 p_count[]。并将 p.length() 个字符分别加入 s_count[] 和 p_count[] 中。若此时 s_count[] 和 p_count[] 相等，则意味着我们找到了第一个异位词，起始索引为 $0$。此时，我们将 $0$ 压入数组 ans 中。随后，我们开始滑动窗口。先弹出最左侧字符 --s_count[s[i] - 'a']，然后将 s[i + p.length()] 加入 s_count[] 中。此时我们比较 s_count[] 和 p_count[] 是否相等。若相等则说明我们找到了一个异位词，起始索引为 $i + 1$，将其压入数组 ans 中。随后，返回数组 ans 即可。

上面这个方法有个问题：每次都需要比较 s_count[] 和 p_count[] 是否完全相等，这浪费了不少时间。因此我们可以考虑使用一个变量 differ 以及一个数组 count[]。用 count[] 存储窗口内字符与 p 字符数的差。用 differ 记录 count[] 的非零元素个数，即当前窗口与字符串 p 中数量不同的字母的个数。然后我们统计一下情况

$$ \begin{cases} \text{字符 c 离开窗口} & \mathrm{count[c]} - 1 = &

\begin{cases} 0 & \text{一个多余字符被移除，differ} - 1 \ -1 & \text{平衡被打破，有新的差异项。differ} + 1 \end{cases} \

\text{字符 c 进入窗口} & \mathrm{count[c]} + 1 = &

\begin{cases} 0 & \text{一个缺失的字符被添加，differ} - 1 \ 1 & \text{平衡被打破，有新的差异项。differ} + 1 \end{cases} \end{cases} $$

也就是说，我们可以仅考虑 differ 的变化来判断当前窗口是否满足要求。

解答

class Solution {
public:
  vector<int> findAnagrams(string s, string p) {
    int s_len = s.length(), p_len = p.length();
    if (s_len < p_len)
      return vector<int>{};

    vector<int> count(26), ans;

    for (auto i = 0; i < p_len; ++i) {
      ++count[s[i] - 'a'];
      --count[p[i] - 'a'];
    }

    auto differ =
        count_if(count.begin(), count.end(), [](int c) { return c != 0; });

    if (differ == 0)
      ans.emplace_back(0);

    for (auto i = 0; i < s_len - p_len; ++i) {
      if (count[s[i] - 'a'] == 1)
        --differ;
      else if (count[s[i] - 'a'] == 0)
        ++differ;

      --count[s[i] - 'a'];

      if (count[s[i + p_len] - 'a'] == -1)
        --differ;
      else if (count[s[i + p_len] - 'a'] == 0)
        ++differ;

      ++count[s[i + p_len] - 'a'];

      if (differ == 0)
        ans.emplace_back(i + 1);
    }

    return ans;
  }
};

无重复字符的最长子串

Tue, 26 Aug 2025 00:00:00 GMT

分析

这道题主要考验滑动窗口的使用。为了记录字符是否出现过，我们可以使用哈希表来存储每个字符。用左右指针标明滑动窗口界限。其中右指针初始值为 -1，左指针初始值为 0。从而表示此时的滑动窗口为空。

随后我们开始调整滑动窗口。首先我们可以固定左指针，当左指针不为0时，左指针会在滑动前滑出指向的字符，从而允许该字符能在右边再次出现。随后我们开始调整右指针。右指针会尽可能的向右移动，直到遇到重复的字符或者到达字符串的末尾。在这期间，程序会更新滑动窗口的最大长度。从而得出答案。

解答

class Solution {
public:
  int lengthOfLongestSubstring(string s) {
    unordered_set<char> persist;
    auto right = -1, ans = 0;
    int n = s.size();

    for (auto left = 0; left < n; ++left) {
      if (left != 0)
        persist.erase(s[left - 1]);

      while (right + 1 < n && !persist.count(s[right + 1]))
        persist.insert(s[++right]);

      ans = max(ans, right - left + 1);
    }

    return ans;
  }
};

长度最小的子数组

Mon, 04 Aug 2025 00:00:00 GMT

分析

如果仅追求能跑的话，这道题其实很简单。两轮循环即可。但在实际中数据量很大。

因此我们可以考虑在两轮循环的基础上使用二分查找。而如何改写成二分查找呢？我们可以利用前缀和的思想。我们先创建个辅助数组 sums 用于保存前缀和。为了方便计算，我们在 sums 的最前面插入一个 0。随后我们可以先固定一个指针 i，然后对整个数组进行二分查找。注意：我们要找的目标是 target + suns[i - 1]。其中 suns[i - 1] 就是前 i - 1 个元素的前缀和。而 target + suns[i - 1] 就是目标值的前缀和。随后我们要对结果进行处理，因为我们二分查找的是前缀和，所以我们要将结果减去 suns[i - 1]，并与现有的结果进行比较，取最小值。其中，二分查找可以用现成的函数，但更推荐自己实现。在此给出一种针对该题的实现方式：

auto binary_search(const vector<int> &nums, int i, int j, const int target) {
  auto ans = -1;

  while (i <= j) {
    auto mid = i + ((j - i) >> 1);

    if (nums[mid] >= target) {
      ans = mid;
      j = mid - 1;
    } else
      i = mid + 1;
  }

  return ans;
}

当然，这道题最优的解法还是使用滑动窗口的办法。前两种方法都是固定一个指针然后进行查找。而我们可以通过指定两个指针 start ,end 来表示滑动窗口的范围。初始情况下，两指针均为 0。在 end 指针移动过程中，我们先求出 end 指针的前缀和，然后通过移动 start 指针来缩小滑动窗口。从而找出满足条件的子数组。

解答

class Solution {
public:
  int minSubArrayLen(int target, vector<int> &nums) {
    int n = nums.size();

    if (n == 0)
      return 0;

    auto ans = INT_MAX, start = 0, end = 0, sum = 0;

    while (end < n) {
      sum += nums[end];

      while (sum >= target) {
        ans = min(ans, end - start + 1);
        sum -= nums[start++];
      }

      end++;
    }

    return ans == INT_MAX ? 0 : ans;
  }
};

三数之和

Fri, 01 Aug 2025 00:00:00 GMT

分析

这道题的关键不在于复杂的数据结构，而在于如何避免重复计算与重复答案。一开始想着先利用两轮循环确定两个数字，然后使用二分来寻找剩余的数字中是否有满足条件的数字。随后想到这其中可能有大量的重复计算，遂考虑 DP。但在实现过程中发现该方法时间复杂度 $O(n^2\log{n})$，似乎不太像 LeetCode 的答案。

官方解答前几个步骤和我前面想法类似。都是先用两轮循环固定住两个数字，但官方解答在寻找第三个数的时候使用了额外的指针。由于题目要求 $i \ne j,\ j \ne k,\ i \ne k$，所以我们在定义第二个和第三个指针的时候要确保内容不能与前一个指针重复。且第三个指针必须要在第二个指针的后面。

当第二个指针和第三个指针相遇时，就不会有 $a + b + c = 0$ 且 $b < c$ 的情况。此时我们可以跳过。当找到满足条件的 c 时，我们可以将 {a, b, c} 压入答案数组 res 中。

解答

class Solution {
public:
  vector<vector<int>> threeSum(vector<int> &nums) {
    int n = nums.size();
    sort(nums.begin(), nums.end());
    vector<vector<int>> res;

    for (auto i = 0; i < n; i++) {
      if (i > 0 && nums[i] == nums[i - 1])
        continue;

      auto k = n - 1, target = -nums[i];

      for (auto j = i + 1; j < n; j++) {
        if (j > i + 1 && nums[j] == nums[j - 1])
          continue;
        while (j < k && nums[j] + nums[k] > target)
          k--;
        if (j == k)
          break;
        if (nums[j] + nums[k] == target)
          res.push_back({nums[i], nums[j], nums[k]});
      }
    }

    return res;
  }
};

盛最多水的容器

Mon, 28 Jul 2025 00:00:00 GMT

分析

这道题如果有双指针的思想难度不大。我们只需要设立左右指针，让他们从两端往中间扫描每个元素，并确保面积始终为最大值即可。

解答

class Solution {
public:
  int maxArea(vector<int> &height) {

    int num = height.size();
    auto left = 0, right = num - 1, ans = 0;

    while (left < right) {
      auto min_height = min(height[left], height[right]);
      ans = max((right - left) * min_height, ans);

      if (height[left] >= height[right])
        right--;
      else
        left++;
    }

    return ans;
  }
};

两数之和 II - 输入有序数组

Sun, 27 Jul 2025 00:00:00 GMT

分析

这道题算不上特别难。基本上一眼就能得出双指针的方法。但在介绍双指针方法之前，先来看一看以二分的思路是如何完成的。

二分的思路是先固定一个数字，然后在右侧二分寻找满足 numbers[left] + numbers[right] == target 的 right。换句话说，在固定好一个数字 numbers[i] 后，我们需要寻找一个满足target - numbers[i] 的 numbers[mid]。由于答案唯一，所以我们在找到后可以直接返回。需要注意的是，二分查找在计算中间值时更重要的是避免潜在溢出，因此通常会写成 left + (right - left) / 2 这样的形式。

而双指针法则更简单。我们只需要两个指针 left 和 right。在 numbers[left] + numbers[right] = target 之前对 left 和 right 进行向中间移动即可。

解答

class Solution {
public:
  vector<int> twoSum(vector<int> &numbers, int target) {
    int left = 0, right = numbers.size() - 1;

    while (left < right) {
      auto sum = numbers[left] + numbers[right];

      if (sum == target)
        return {left + 1, right + 1};
      else if (sum > target)
        right--;
      else
        left++;
    }

    return {-1, -1};
  }
};

判断子序列

Thu, 24 Jul 2025 00:00:00 GMT

分析

这道题非常简单，双指针即可轻松判断。因为是子序列，所以后一个字符必须在前一个字符之后出现。因此我们可以在一个循环内完成判断：当慢指针移动到 s 的末尾时，说明 s 已经匹配完成，可以直接返回 true。如果遍历完整个 t 后慢指针仍未到达 s 的末尾，则返回 false。

当然，这道题还可以用动态规划的方法来解决。但动态规划方法对于这道题而言过于复杂。因为每个位置的状态依赖后续位置的状态，所以我们通过倒序来装填 dp[][]。首先，我们要确定状态转移的边界。令 m = t.size()。那我们可以让 dp[m][i] 全为 m 来表示虚拟边界。其次，我们写出状态转移方程。

$$ \mathrm{dp[i][j]} = \begin{cases} i & \mathrm{t[i]} = j \ \mathrm{dp[i + 1][j]} & \mathrm{t[i]} \ne j \end{cases} $$

根据以上方程，我们即可完成 dp[][] 的填充。

现在我们开始查找：我们先定义一个 add 用于表示搜索起始位置。令 c = s[i]，则我们判断 dp[add][c - 'a'] 是否等于 m。若等于则说明未能找到字符 c，即不符合子序列的要求。若不等于，则可以将 add 更新为 dp[add][c - 'a'] + 1。直到遍历结束。

解答

class Solution {
public:
  bool isSubsequence(string s, string t) {
    if (s.size() > t.size())
      return false;

    int m = t.size();
    vector<vector<int>> dp(m + 1, vector<int>(26, 0));

    for (auto i = 0; i < 26; ++i)
      dp[m][i] = m;

    for (auto i = m - 1; i >= 0; --i)
      for (auto j = 0; j < 26; ++j)
        dp[i][j] = t[i] == j + 'a' ? i : dp[i + 1][j];

    auto add = 0;

    for (auto c : s) {
      if (dp[add][c - 'a'] == m)
        return false;
      add = dp[add][c - 'a'] + 1;
    }

    return true;
  }
};

文本左右对齐

Mon, 21 Jul 2025 00:00:00 GMT

分析

这道题相对同组其他题来说比较繁琐，究其原因是因为这更像道业务逻辑题而不是算法题。我们只需要抓住三种情况：

当前行是最后一行：单词左对齐，单词间有且仅有一个空格。其余空格在末尾补充从而对齐。
当前行不是最后一行，但只有一个单词：该单词左对齐，在末尾填充空格从而对齐。
当前行不是最后一行且不止一个单词：设当前单词数为 num_words，单词间空格数为 num_spaces 。因为我们要在单词周围均匀分配空格，所以单词之间至少有空格 $\mathrm{avg_spaces} = \frac{\mathrm{num_spaces}}{\mathrm{num_words - 1}}$ 对于多出来的空格 $\mathrm{extra_spaces} = \mathrm{num_spaces}\bmod{(\mathrm{num_words} - 1)}$，应该填充在前 extra_spaces 个单词的之间。也就是说，前 extra_spaces 个单词应该填充 avg_spaces + 1 个空格，其余的单词应该填充 avg_spaces 个空格。

解答

class Solution {
private:
  auto blank(int n) { return string(n, ' '); }
  auto join(const vector<string> &words, int left, int right,
            const string &sep) {
    auto s = words[left];
    for (auto i = left + 1; i < right; ++i)
      s += sep + words[i];

    return s;
  }

public:
  vector<string> fullJustify(vector<string> &words, int maxWidth) {
    vector<string> ans;
    auto right = 0;
    int n = words.size();
    while (true) {
      auto left = right;
      auto sum_len = 0;

      while (right < n &&
             sum_len + words[right].length() + right - left <= maxWidth)
        sum_len += words[right++].length();

      if (right == n) {
        auto s = join(words, left, n, " ");
        ans.emplace_back(s + blank(maxWidth - s.length()));
        return ans;
      }

      auto num_words = right - left;
      auto num_spaces = maxWidth - sum_len;

      if (num_words == 1) {
        ans.emplace_back(words[left] + blank(num_spaces));
        continue;
      }

      auto avg_spaces = num_spaces / (num_words - 1);
      auto extra_spaces = num_spaces % (num_words - 1);
      auto s1 =
          join(words, left, left + extra_spaces + 1, blank(avg_spaces + 1));
      auto s2 = join(words, left + extra_spaces + 1, right, blank(avg_spaces));
      ans.emplace_back(s1 + blank(avg_spaces) + s2);
    }
  }
};

验证回文串

Mon, 21 Jul 2025 00:00:00 GMT

分析

这道题最直观的方法就是利用双指针进行前后遍历。我们可以先利用 erase() 配合 remove_if() 以及 isalnum() 移除所有非法字符。然后利用 transform() 将所有字符转换为小写。接着就可以使用双指针进行前后遍历判断是否回文了。

当然，我们还可以直接在原字符串上判断，从而节省额外空间。我们可以利用上文提到的 isalnum() 函数，在遇见非法字符时进行跳过。然后直接利用 tolower() 对字符进行立即转换并判断。

解答

class Solution {
public:
  bool isPalindrome(string s) {
    int n = s.size();
    auto left = 0, right = n - 1;

    while (left < right) {
      while (left < right && !isalnum(s[left]))
        left++;
      while (left < right && !isalnum(s[right]))
        right--;
      if (left < right)
        if (tolower(s[left++]) != tolower(s[right--]))
          return false;
    }

    return true;
  }
};

接雨水

Wed, 16 Jul 2025 00:00:00 GMT

分析

要解答这题，首先要明确什么情况下可以接到雨水。从题目给出的示意图不难看出：只有当当前位置左右两侧都存在更高的挡板时，该位置才可能积水。因此，我们可以参照 135 题那样的办法，通过前后两次遍历来解决。首先，我们从左往右遍历，记录每个位置的最大高度 max(height[i], max_left[i-1])。然后，我们再从右往左遍历，记录每个位置的最大高度 max(height[i], max_right[i+1])。最后，我们取两侧最大高度的较小值，从而计算出每个位置可以接到的雨水，即 min(max_left[i], max_right[i]) - height[i]。

我们也可以使用单调栈的方法来解决这个问题。在此题中，我们用单调栈存储下标。当遍历到下标 i 时，我们做以下判断：

如果当前柱子高度不高于栈顶柱子，则直接将 i 压入栈。
如果当前柱子高于栈顶柱子，说明此时一个储水区域已经形成。这时：
- 栈顶元素 top 为区域底部。
- 当前元素 i 为区域右墙。
- top 出栈的栈顶元素 left 为区域左墙。

因此，该区域的宽度为 $\mathrm{i} - \mathrm{left} - 1$，高度为 $\min{(\mathrm{height}[\mathrm{left}], \mathrm{height}[\mathrm{i}])} - \mathrm{height}[\mathrm{top}]$。由于右墙 i 可能为递增序列，因此我们需要重复出栈和计算的过程。直到该单调栈为空或者找到一个低于当前右墙高度的柱子为止。

同 135 题一样，我们也可以在两次遍历的基础上使用双指针进行优化。经过观察，不难发现某个位置能接到的雨水取决于其左侧最高挡板和右侧最高挡板中的较小值。我们可以将这两个数组优化为指针，并分别设置两个变量记录当前两侧的最大高度。随后，两个指针分别从最左侧或最右侧开始向中间遍历。此时有：

$\mathrm{height}[\mathrm{left}]<\mathrm{height}[\mathrm{right}]$。此时可以优先确定 left 位置的积水量，因此 left 处能接到的雨水为 max_left - height[left]。并将 left 向右移动。
$\mathrm{height}[\mathrm{left}]\ge\mathrm{height}[\mathrm{right}]$。此时可以优先确定 right 位置的积水量，因此 right 处能接到的雨水为 max_right - height[right]。并将 right 向左移动。

当两个指针相遇时，即可得到最终结果。

解答

class Solution {
public:
  int trap(vector<int> &height) {
    auto ans = 0, left = 0, max_left = 0, max_right = 0;
    int right = height.size() - 1;

    while (left < right) {
      max_left = max(max_left, height[left]);
      max_right = max(max_right, height[right]);

      ans += height[left] < height[right] ? max_left - height[left++]
                                          : max_right - height[right--];
    }

    return ans;
  }
};

分发糖果

Sat, 12 Jul 2025 00:00:00 GMT

分析

这道题难道中等。核心问题在于如何正确处理两种情况：

比左边的人分数高
比右边的人分数高

为了解决这个问题。我们可以进行两次遍历，一次从左往右遍历且只考虑情况 1，一次从右往左遍历且只考虑情况 2。在从右往左便利的过程中，比较当前结果和从左往右遍历至当前位置的结果，取最大值。这样，我们就能保证时间复杂度和空间复杂度均为 $O(2N) = $O(N)$。

那有没有更好的办法呢？我们可以从情况 1 的角度考虑：如果当前分数大于等于左边人的分数，那证明此时我们处于一个递增的序列当中。那我们可以采用上一个题从左往右便利的思路去做, 使用变量 pre 来记录上一个人所分的糖果数，用变量 inc 来记录当前递增序列的长度。那么当不满足情况 1 的时候，那证明我们在递减序列中。我们可以定义一个变量 des 。通过 des++ 来记录当前递减序列的长度。

现在有个新的问题：假设存在这么一个数列： $[1, 3, 2, 1]$，且我们已经给第一位分配了一颗糖果。现在我们开始遍历：

当 idx = 3 时，因为 $3 > 1$，所以我们给第二位分配两颗糖果。
当 idx = 2 时，因为 $2 < 3$，所以我们给第三位分配一颗糖果。
当 idx = 1 时，因为 $1 < 2$，所以我们给第四位分配 award[2] - 1 颗糖果。但根据第二步， $\mathrm{award}[2] = 1$，所以不符合题意。

那么我们该怎么修复这个 bug 呢？

回想一下，我们定义了一些变量：pre, inc, dec. pre 是用来记录上一个人分的糖果，在递增序列中我们要给当前人分配 pre + 1 个糖果。 inc 用于记录当前递增序列的长度，同样也是当前序列的最大值。 dec 用于记录递减序列的长度。现在我们分三种情况情况来考虑：

$\mathrm{rating}[\mathrm{idx}] > \mathrm{rating}[\mathrm{idx} - 1]$。此时我们处于递增的序列当中，在递增序列中我们要给当前人分配 pre + 1 个糖果。因此 inc 与 pre 需要自增。
$\mathrm{rating}[\mathrm{idx}] = \mathrm{rating}[\mathrm{idx} - 1]$。此时我们处于一个序列的断裂点。因此 inc 和 pre 都会被重置为 1。
$\mathrm{rating}[\mathrm{idx}] < \mathrm{rating}[\mathrm{idx} - 1]$。此时我们处于一个递减序列当中。因为 dec 是个变量，所以我们不需要严格遵守「有序地求出从左往右对应糖果数量」。在分配之前，我们先让 dec++，然后做以下判断：
- 如果 $\mathrm{dec} < \mathrm{inc}$，那么证明此时我们处于一个比前一个序列短的递减序列中。当前人所分的糖果就是自增后的 dec。
- 如果 $\mathrm{dec} = \mathrm{inc}$，那么此时递减序列的长度与递增序列相等。就像例子中的最后一项一样。这时我们应该在 dec++ 的基础上再次 dec++。第一次的自增和上述情况一样，是表示当前人所分的糖果数。再次自增则保证了 rating 数组最大值的人能得到最多的糖果。

此时为了维护 des，我们需要在非递减序列中令 des = 0。从而保证 des 不会大于 inc，即保证不会超过 rating 数组最大值的人能得到最多的糖果。

解答

class Solution {
public:
  int candy(vector<int> &ratings) {
    auto n = ratings.size();
    auto ans = 1;
    auto inc = 1;
    auto dec = 0;
    auto pre = 1;

    for (auto i = 1; i < n; ++i) {
      if (ratings[i] >= ratings[i - 1]) {
        dec = 0;
        pre = ratings[i] == ratings[i - 1] ? 1 : pre + 1;
        ans += pre;
        inc = pre;
      } else {
        dec++;
        if (dec == inc)
          dec++;
        pre = 1;
        ans += dec;
      }
    }

    return ans;
  }
};

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

Wed, 09 Jul 2025 00:00:00 GMT

分析

这道题虽然标是 easy，但仅在使用暴力时为 easy。如果要用 KMP 算法的思路去做那么难度将会大大上升。

先从暴力搜索的思路去看，因为我们是匹配字符串，所以要确保相应的字符串是连续且完全匹配的。现在我们定义两个变量如下：

auto n = haystack.size();
auto m = needle.size();

因为我们要确保字符串连续且相同，所以外层循环中结束条件应为 i + m <= n。内层循环中，为了减少开始位置的判断，我们可以始终令 j = 0。而具体的判断的索引则为 i + j。当匹配过程中发现不匹配时，应该立即打断而不是返回 -1。因为可能存在诸如被匹配项为 aaaaaaaab，匹配项为 aaab 的情况。

关于 KMP 解法。我们要先算出 PM 数组。然后使用 PM 数组和要匹配的字符串进行比较。当遍历到 PM 最后一项且相等时，匹配成功。

解答

class Solution {
public:
  int strStr(string haystack, string needle) {
    if (needle.size() == 0)
      return 0;

    auto n = haystack.size();
    auto m = needle.size();

    vector<int> pm(m);

    for (auto i = 1, j = 0; i < m; ++i) {
      while (j > 0 && needle[i] != needle[j])
        j = pm[j - 1];
      if (needle[i] == needle[j])
        ++j;
      pm[i] = j;
    }

    for (auto i = 0, j = 0; i < n; ++i) {
      while (j > 0 && haystack[i] != needle[j])
        j = pm[j - 1];
      if (haystack[i] == needle[j])
        ++j;
      if (j == m)
        return i - m + 1;
    }

    return -1;
  }
};

Z 字形变换

Tue, 08 Jul 2025 00:00:00 GMT

分析

这道题题目误导性有点强。准确说来说应该是个反向的 N 而不是 Z。现在让我们重新来看一下题目给出的例子。在压缩不必要的空行后，不难看出，这个排列是自上往下，从 0 递增到 numRows - 1。当到达 numRows - 1 时，改变遍历方向，从下往上递减回 0。因此，我们不难想到利用一个参数 flag。在当前索引为 0 或者 numRows - 1 时，改变 flag 的正负。从而实现控制遍历方向的功能。

当然，这样的解法还有优化的空间。在此之前，我们先需要推导一下这个反向 N 的变化逻辑。还是以题目的例子为例。我们先需要向下遍历 $r = 3$ 行（一开始为空所以需要从 0 开始遍历），然后向上遍历回到 $r - 2 = 1$ 行。因此周期为 $t = r + r - 2 = 2r - 2$。而每个周期会占用 $1 + r - 2 = r - 1$ 列。

假设最后一个周期为完整的周期，那我们不难的得出总共有 $\begin{bmatrix} n \ t \end{bmatrix}$ 个周期。乘上每个周期的列数，则得到矩阵的列数为 $\begin{bmatrix} n \ t \end{bmatrix} \cdot (r - 1)$。

因此，对于第一行非空字符，其索引均为周期的倍数。令索引为 $\mathrm{idx}$，则有 $\mathrm{idx} = 0\pmod{t}$。最后一行则有 $\mathrm{idx} = r - 1\pmod{t}$。而对于其余行，假设行号为 $i$。在题目的例子中每个周期内中间行有两个字符。因此分别满足 $\mathrm{idx}=i\pmod{t}$ 和 $\mathrm{idx} = t - i\pmod{t}$。

解答

class Solution {
public:
  string convert(string s, int numRows) {
    if (numRows < 2)
      return s;

    int n = s.size();
    auto r = numRows;

    string ans;

    auto t = r * 2 - 2;

    for (auto i = 0; i < r; ++i)
      for (auto j = 0; j + i < n; j += t) {
        ans += s[j + i];
        if (i > 0 && i < r - 1 && j + t - i < n)
          ans += s[j + t - i];
      }

    return ans;
  }
};

反转字符串中的单词

Mon, 07 Jul 2025 00:00:00 GMT

分析

这道题难点在于如何正确处理空格。我的思路是从后往前遍历，先像 58 题那样处理尾空格，然后再利用 substr 来截取单词。并根据 result 数组是否为空来决定是否加入前置空格。

当然，这道题可以利用 C++ 中的可变字符串特性来解决。在开始前，我们先反转整个字符串。然后先退空格，然后利用快慢指针截取单词并翻转。其中满指针可以通过判断是否值为 0 来决定是否添加空格。

解答

class Solution {
public:
  string reverseWords(string s) {
    auto n = s.size();
    auto idx = 0;

    reverse(s.begin(), s.end());

    for (auto start = 0; start < n; ++start) {
      if (s[start] != ' ') {
        if (idx != 0)
          s[idx++] = ' ';

        auto end = start;
        while (end < n && s[end] != ' ')
          s[idx++] = s[end++];

        reverse(s.begin() + idx - (end - start), s.begin() + idx);

        start = end;
      }
    }

    s.erase(s.begin() + idx, s.end());
    return s;
  }
};

最后一个单词的长度

Sat, 28 Jun 2025 00:00:00 GMT

分析

这题难度不大。既然只需要计算最后一个单词的长度，那么只需要从后向前遍历一次就可以了。但需要注意题目中给的例子后面部分有不等数量的空格，所以在正式计数前我们要先过滤空格。随后计算遇到下一个空格的位置即可。

解答

class Solution {
public:
  int lengthOfLastWord(string s) {
    int idx = s.size() - 1;

    while (s[idx] == ' ')
      idx--;

    auto num = 0;

    while (idx >= 0 && s[idx] != ' ') {
      num++;
      idx--;
    }

    return num;
  }
};

最长公共前缀

Sat, 28 Jun 2025 00:00:00 GMT

分析

这道题其实非常简单。按照常规思维来看，我们只需要对字符串进行纵向扫描，分别对比字符串的每个字母，当字母不一样时停止扫描并返回当前存储的结果。

但是，这道题的思路可以进一步拓展。首先，假设字符串成员为 strs = ['leet', 'leetcode', 'lee', 'le']。我们可以对字符串进行分治。即分别对 strs = ['leet', 'leetcode'] 和 strs = ['lee', 'le'] 进行分治。求出 strs = ['leet', 'leetcode'] 的最长公共前缀为 leet， strs = ['lee', 'le'] 的最长公共前缀为 le。随后，我们对这两个字符串进行比较，得到 leet 与 le 的最长公共前缀为 le。

当然，此题还可以利用二分查找的思路进行解答。显然，最长公共前缀小于等于最短字符串的长度，所以我们先找出最短字符串的长度 min_len。然后，我们取字符串中间值 mid，先比较每个字符串的前 mid 个字符，若都相同则以 mid+1 为起点比较后 len - (mid + 1) 个字符。从而将搜索范围缩小，得出答案。

解答

class Solution {
public:
  string longestCommonPrefix(vector<string> &strs) {
    if (!strs.size())
      return "";

    auto min_len = min_element(strs.begin(), strs.end(),
                               [](const string &s, const string &t) {
                                 return s.size() < t.size();
                               })
                       ->size();
    auto low = 0;
    auto high = min_len;

    while (low < high) {
      auto mid = (high - low + 1) / 2 + low;

      if (isCommonPrefix(strs, mid))
        low = mid;
      else
        high = mid - 1;
    }

    return strs[0].substr(0, low);
  }

  bool isCommonPrefix(const vector<string> &strs, int len) {
    auto str0 = strs[0].substr(0, len);
    auto cnt = strs.size();

    for (auto i = 0; i < cnt; ++i) {
      auto str = strs[i];

      for (auto j = 0; j < len; ++j)
        if (str[j] != str0[j])
          return false;
    }

    return true;
  }
};

整数转罗马数字

Tue, 24 Jun 2025 00:00:00 GMT

分析

一开始我以为和 13 题一样从后往前处理即可，后来发现直接按位拆分会更清晰。

答案中给了两种方法。第一种是从大到小先建立一个映射表 table 并开始遍历，当发现当前值 num 不小于 table[i] 时，就输出对应字符并减去相应的值。从而得出答案。但这样的方法有个问题：虽然时间复杂度为 $O(1)$，但实际运行会受到映射大小的影响。本题条件最大的循环次数不会超过15。

第二种虽然也是通过映射实现，但比第一种考虑得更周到：通过归纳，我们不难发现：

千位只能由 M 表示。
百位只能由 C, CD, D, CM 表示。
十位只能由 X，XL，L 和 XC 表示。
个位只能由 I，IV，V 和 IX 表示。

因此，我们可以将其分为四组，且每组没有公共符号。因此，每个数字我们都可以进行单独处理。即，我们可以根据每个位上的数字来寻找对应的罗马字符。随后拼接在一起，即为所求。

解答

class Solution {
public:
  string intToRoman(int num) {
    const string thousands[] = {"", "M", "MM", "MMM"};
    const string hundreds[] = {"",  "C",  "CC",  "CCC",  "CD",
                               "D", "DC", "DCC", "DCCC", "CM"};
    const string tens[] = {"",  "X",  "XX",  "XXX",  "XL",
                           "L", "LX", "LXX", "LXXX", "XC"};
    const string ones[] = {"",  "I",  "II",  "III",  "IV",
                           "V", "VI", "VII", "VIII", "IX"};

    return thousands[num / 1000] + hundreds[num % 1000 / 100] +
           tens[num % 100 / 10] + ones[num % 10];
  }
};

罗马数字转整数

Tue, 24 Jun 2025 00:00:00 GMT

分析

这题按题意直接写 if-else 也能完成，但那样的写法可读性一般，可扩展性也较差。但官方解答也有可取之处：从左往右的角度看，小的数字位于大的左边，则 ans 减去当前值。比如 $IV$，因为 $I < V$，所以我们应该 $\mathrm{ans} - 1 + 5$。反之则 ans += val。

解答

class Solution {
public:
  int romanToInt(string s) {
    unordered_map<char, int> symbol_values = {
        {'I', 1},   {'V', 5},   {'X', 10},  {'L', 50},
        {'C', 100}, {'D', 500}, {'M', 1000}};
    auto ans = 0;
    auto n = s.length();

    for (auto i = 0; i < n; ++i) {
      auto val = symbol_values[s[i]];
      if (i < n - 1 && val < symbol_values[s[i + 1]])
        ans -= val;
      else
        ans += val;
    }

    return ans;
  }
};

加油站

Tue, 10 Jun 2025 00:00:00 GMT

分析

此题核心思路在于如何减少遍历的次数。依据题意，我们不难得出需要针对 (i + 1) % n 进行两次遍历。假设符合题意的起点加油站为 $x$，终点站为 $y$。$z$ 为两者中间的任意一个加油站。则我们耐心观察后就会得出以下两个等式：

$\sum^y_{i=x} \mathrm{gas[i]} < \sum^y_{i=x}{\mathrm{cost[i]}}$。即到达最后的加油站后，前往下一个加油站所需要消耗的油量比现有油量要多
$\sum^y_{i=x} \mathrm{gas[i]} \ge \sum^j_{i=x}{\mathrm{cost[i]}}$。即在到最后的加油站以及之前所需的油量比现有油量少。

因此，我们可以做以下变形：

$$ \begin{aligned} \sum^y_{i=z}\mathrm{gas[i]} & = \sum^y_{i=x}\mathrm{gas[i]}

\sum^{z-1}{i=x}\mathrm{gas[i]} \ & \le \sum^y{i=x}\mathrm{cost[i]}
\sum^{z-1}{i=x}\mathrm{gas[i]} \ & \le \sum^y{i=x}\mathrm{cost[i]}
\sum^{z-1}{i=x}\mathrm{cost[i]} \ & = \sum^y{i=z}\mathrm{cost[i]} \end{aligned} $$

即 $x$ 与 $y$ 之间，不存在任何一个加油站，使得汽车能到达 $y$ 后下一个加油站。

因此，我们可以先从 0 号加油站开始检查并判断能否环绕一周。如果不能则从第一个失败的加油站重新开始检查。以此类推，直到得出结果。

解答

class Solution {
public:
  int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
    auto n = gas.size();
    auto i = 0;

    while (i < n) {
      auto sum_cost = 0;
      auto sum_gas = 0;
      auto cnt = 0;

      while (cnt < n) {
        auto j = (i + cnt) % n;
        sum_gas += gas[j];
        sum_cost += cost[j];

        if (sum_cost > sum_gas)
          break;

        cnt++;
      }

      if (cnt == n)
        return i;
      else
        i = i + cnt + 1;
    }

    return -1;
  }
};

除自身以外数组的乘积

Sun, 25 May 2025 00:00:00 GMT

分析

解决本题的难点在于如何在不不使用除法也能完成题目的要求。

一种方法是另外建立两个新数组 L[len], R[len]，分别存储 $i - 1$、$i + 1$ 的乘积。然后在 ans 数组中再相乘。这样做虽然保证了时间复杂度为 $O(N)$，但空间复杂度也为 $O(N)$。

那有什么办法优化呢？我们可以把 ans[] 先当成 L[] 来进行初始化与计算。而将 R 数组变成一个跟踪右边元素的乘积。并实时更新 R 的值。为了让 R 能正确存储 $i + 1$ 的乘积. R 应该从 len - 1 开始索引。解答如下节所示。

解答

class Solution {
public:
  vector<int> productExceptSelf(vector<int> &nums) {
    auto length = nums.size();
    vector<int> answer(length);

    answer[0] = 1;
    for (auto i = 1; i < length; ++i)
      answer[i] = nums[i - 1] * answer[i - 1];

    auto R = 1;
    for (int i = length - 1; i >= 0; --i) {
      answer[i] = answer[i] * R;
      R *= nums[i];
    }

    return answer;
  };
};

O(1) 时间插入、删除和获取随机元素

Thu, 22 May 2025 00:00:00 GMT

分析

看见插入和删除都要求 $O(1)$，很自然会先想到使用数组。不过，仅靠数组虽然可以做到按下标随机访问为 $O(1)$，但删除任意元素通常需要移动后续元素，因此难以保证删除操作也是 $O(1)$。因此我们需要引入额外的数据结构来配合实现。

注意到题目中并没有限制空间复杂度。因此我们可以通过引入哈希表，用哈希表记录数组下标。通过哈希表判断元素是否存在并记录其下标，就可以配合数组满足题目的时间复杂度要求。删除操作中，由于直接删除会涉及到后续元素的前移，所以我们可以交换目标元素与数组最后一个元素的位置。从而在常数时间里移除元素。

解答

class RandomizedSet {
private:
  vector<int> nums;
  unordered_map<int, int> indices;
  mt19937 rng;
  uniform_int_distribution<int> dist;

public:
  RandomizedSet() {}

  bool insert(int val) {
    if (indices.count(val))
      return false;

    auto index = nums.size();
    nums.emplace_back(val);
    indices[val] = index;

    return true;
  }

  bool remove(int val) {
    if (!indices.count(val))
      return false;

    auto index = indices[val];
    auto last = nums.back();
    nums[index] = last;
    indices[last] = index;
    nums.pop_back();
    indices.erase(val);

    return true;
  }

  int getRandom() {
    uniform_int_distribution<int>::param_type parm(0, nums.size() - 1);

    return nums[dist(rng, parm)];
  }
};

H 指数

Mon, 19 May 2025 00:00:00 GMT

分析

这道题的难点在于如何高效找到 H 指数。一开始我是想到了利用计数排序来实现：通过引入一个额外的数组 nums[]，用类似我们之前建立 Hash Table 的方法来记录引用次数。其中，nums[i] 用于表示引用次数恰好为 $i$ 的论文数。考虑到 H 指数不可能大于论文发表数，所以我们可以将所有引用次数超过论文发表数的算入总发表数（即 nums[nums.length]）。接着，我们可以逆序遍历这个数组，当“引用次数至少为当前值”的论文数量不少于当前值时，即为我们所求的 H 指数。

当然，这个方法虽然很快，但要引入一个辅助数组，这增加了空间复杂度。因此，我们需要找到一个更好的方法。我们可以将问题转换为寻找「有 h 篇论文引用次数至少为 h」的最大值。因此，我们可以利用二分查找快速寻找出这个最大值。当 left = right 时，此时 left 即为所求。解答如下文所示。

解答

class Solution {
public:
  int hIndex(vector<int> &citations) {
    auto left = 0;
    auto right = citations.size();

    while (left < right) {
      auto mid = (left + right + 1) >> 1;
      auto cnt = count_if(citations.begin(), citations.end(),
                          [mid](auto val) { return val >= mid; });
      if (cnt >= mid)
        left = mid;
      else
        right = mid - 1;
    }
    return left;
  }
};

搭建监控平台（二）

Wed, 14 May 2025 00:00:00 GMT

前言

在上一篇博文中，我们完成了监控平台的初步搭建。但光有监控还不够，在 OOM、磁盘即将满、BTRFS 出现错误等情况时，我们可能会因为未能及时监控到而导致服务器出现异常。为了解决这个问题，我们可以利用 Prometheus 的告警功能，对一些常见异常情况设置告警规则。并经由 Alertmanager 进行统一管理并转发。本博文拟针对一些常见情况设置自动告警，并经由 Alertmanager 往指定邮箱发送告警邮件。

配置 Prometheus

关联 Alertmanager

在正式设置警告规则前，我们应该关联 Prometheus 与 Alertmanager，让 Prometheus 正确向 Alertmanager 发送告警信息：

#/etc/prometheus/prometheus.yml
alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

配置告警规则

首先，应该创建一个子目录用于维护告警规则：

mkdir -p /etc/prometheus/rules

然后在配置文件引入这个目录：

#/etc/prometheus/prometheus.yml
rule_files:
  - '/etc/prometheus/rules/*.yml'

接着我们创建相关的告警规则：

#/etc/prometheus/rules/system.yml
groups:
  - name: hostStatsAlert
    rules:
      - alert: CPUHighUse
        expr: '(1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100 > 85'
      - alert: DiskFull
        expr: 'node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} < 0.15'
      - alert: MemoryLow
        expr: 'node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes < 0.15'
      - alert: NodeDown
        expr: 'up == 0'

然后重启 Prometheus：

systemctl restart prometheus

安装并配置 Alertmanager

Alertmanager 同样可以直接通过发行版仓库安装。

紧接着对其进行简单配置，让它通过指定的 Gmail 邮箱向目标邮箱发送告警邮件：

#/etc/alertmanager/alertmanager.yml
global:
  smtp_smarthost: smtp.gmail.com:587
  smtp_from: <发送邮箱地址>
  smtp_auth_username: <发送邮箱用户名>
  smtp_auth_password: <发送邮箱密码>

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'email'

receivers:
  - name: email
    email_configs:
      - to: <接收邮箱地址>
        send_resolved: true

inhibit_rules:
  - source_match:
      severity: 'critical'
    target_match:
      severity: 'warning'
    equal: ['alertname', 'dev', 'instance']

然后启动 Alertmanager：

systemctl enable --now alertmanager

搭建监控平台（一）

Sun, 11 May 2025 00:00:00 GMT

选型

最近终于有时间折腾一下 homelab。我准备了一台 4C + 4G + 60G 的虚拟机，用来实践 Linux 环境下的监控方案。

现在第一步就是搭建一个检测虚拟机状态的平台。在搜索后决定用 Prometheus + Grafana 的架构来搭建。

流程

安装及初启动

首先我们需要安装上述软件。为了同时监控系统资源，还需要额外安装 node_exporter。我在选择的发行版中官方仓库已经有相关包，这里直接选择使用包管理器安装：

sudo dnf install grafana prometheus node_exporter

然后启动这些服务：

systemctl enable --now grafana prometheus node_exporter

现在我们就完成了安装以及初次启动。

配置

上文提到， Prometheus 如果要监控系统资源，要额外安装 node_exporter。现在我们对 Prometheus 进行配置来启用这个插件：

# /etc/prometheus/prometheus.yml
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
        labels:
          app: 'prometheus'
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']

然后重启服务：

systemctl restart prometheus

即可完成插件启用。

现在让我们测试一下：

❯ sudo ss -tulnp | grep -E "9090|9100"
[sudo] password for elysium:
tcp   LISTEN 0      4096       127.0.0.1:9090       0.0.0.0:*    users:(("prometheus",pid=54760,fd=6))
tcp   LISTEN 0      4096               *:9100             *:*    users:(("node_exporter",pid=54759,fd=3))

此时相关服务已经正常运行。

现在让我们看看 Grafana。 Grafana 的 Web 界面已经提供了较完整的引导，我们只需要按提示导入 Prometheus 数据源即可。关于 Dashboard，官方内置模板相对基础，我这里更推荐使用 Node Exporter Full。配置时输入 1860 导入即可。

路由转发

在实际环境中，通常不会直接将 3000 端口暴露到互联网。因此，我们通常会通过反向代理暴露一个受控的访问路径，供管理员使用。比如域名为 foo.bar，则需要访问 foo.bar/monitor 来进行访问。

为了实现这样的功能，我们需要对 grafana 设置如下：

# /etc/grafana/grafana.ini
[server]
domain = foo.bar
root_url = %(protocol)s://%(domain)s/monitor/
serve_from_sub_path = true

然后对 nginx 设置如下：

# /etc/nginx/nginx.conf
server {
  location /monitor/ {
    proxy_pass http://localhost:3000/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

然后重启这两个服务

systemctl restart nginx grafana

现在我们可以通过访问 https://foo.bar/monitor/ 来访问 Grafana。

跳跃游戏

Sun, 20 Apr 2025 00:00:00 GMT

分析

这题的核心在于维护“当前能够到达的最远位置”。

更合适的做法是使用贪心思路来解答。当 max_jump 的值大于等于 i 时，意味着此时 i 可达。此时可通过比较 max_jump 和 i + nums[i] 的最大值，并将结果存储在 max_jump 中。而当 max_jump 大于等于数组最大索引时，说明最后一个位置可达，返回 true。如果遍历过程中出现 i > max_jump，则当前位置不可达，应返回 false。

解答

class Solution {
public:
  bool canJump(vector<int> &nums) {
    auto max_jump = 0;
    auto n = nums.size();

    if (n == 1)
      return true;

    for (auto i = 0; i < n; ++i) {
      if (i <= max_jump) {
        max_jump = max(max_jump, i + nums[i]);

        if (max_jump >= n - 1)
          return true;
      } else
        break;
    }

    return false;
  }
};

跳跃游戏2

Sun, 20 Apr 2025 00:00:00 GMT

分析

个人比起 55 题更难了。这题的重点在于如何进行「贪心」地向后查找。以 [2, 3, 1, 1, 4] 为例： i = 0 时，最大跳跃距离为 2， i = 1 时，最大跳跃距离为 3。因此，我们可以维护一个当前可到达的边界 max_jump。到达边界时，更新边界值并增加跳跃次数。

解答

class Solution {
public:
  int jump(vector<int> &nums) {
    auto count = 0;
    auto end = 0;
    auto max_jump = 0;
    auto n = nums.size();

    for (auto i = 0; i < n - 1; ++i) {
      max_jump = max(max_jump, nums[i] + i);

      if (max_jump >= n - 1)
        return count + 1;

      if (i == end) {
        end = max_jump;
        count++;
      }
    }

    return count;
  }
};

买卖股票的最佳时机2

Thu, 17 Apr 2025 00:00:00 GMT

分析

这题相比于 121 题，关键在于多了一个条件「可以当天卖出的同时买入，但同时只能持有一股」。所以问题从「找出最小值，并在此之后找到最大值」变成了「尽可能找到一系列不相交的区间，记录所有区间的左右差值（右减左）大于 $0$ 的区间」。

因此这题有两种方案实现：

动态规划。因为当日盈亏情况均由昨日决定。所以我们可以通过变量记录昨天是否持有股票（dp0, dp1），然后通过方程 dp0_now=max{dp0,dp1+price} 来记录不持有的情况下收益最大化的转移方程。并通过 dp1_now=max{dp1,dp0-price} 来记录持有股票的情况下损失最小化的转移方程。最后一天要同时做到利益最大化以及损失最小化，所以必然为 dp0。
贪心。我们只需要寻找 n 个区间为 $1$，且卖出 $>$ 买入的区间就行。具体代码如下所示。

解答

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

    for (auto i = 1; i < n; ++i)
      ans += max(0, prices[i] - prices[i - 1]);

    return ans;
  }
};

买卖股票的最佳时机

Wed, 16 Apr 2025 00:00:00 GMT

分析

这题抓住一个点：找到历史最低点购入，并在这之后找到利润最高点。即求「卖出价格-买入价格」的最大值。

解答

class Solution {
public:
  int maxProfit(vector<int> &prices) {
    auto buy = prices[0];
    auto profit = 0;

    for (auto price : prices) {
      profit = max(profit, price - buy);
      buy = min(buy, price);
    }

    return profit;
  }
};

多数元素

Mon, 14 Apr 2025 00:00:00 GMT

分析

由于多数元素占比超过 $\frac{n}{2}$，所以我们可以直接通过调用 sort() 来排序，并返回索引为 $\frac{n}{2}$ 的元素。

当然，如果不考虑进阶要求空间复杂度为 $O(1)$，我们也可以通过调用哈希表。利用键值对来统计每个元素及其出现次数。并通过类似打擂台的方式来维护最大值。

本题中，最佳办法是官方解法中的 Boyer-Moore 投票算法。具体算法正确性可见 LeetCode 官方题解。其原理为：定义为一个候选众数 candidate，并定义出现次数 count = 0，当前数为 $x$。

当 count < 0 时，定义 $x$ 为 candidate。然后做以下判断：

candidate = x; count++;
candidate != x; count--;

因为众数数量超过数组长度的 $\frac{1}{2}$。令众数数量为 $n$，则在次情况下总共有 n - num.size()/2 的数没有消除。也就是说，最后得出的 candidate 自然为众数。

解答

class Solution {
public:
  int majorityElement(vector<int> &nums) {
    auto candidate = -1;
    auto count = 0;

    for (auto num : nums) {
      if (num == candidate)
        ++count;
      else if (--count < 0) {
        candidate = num;
        count = 1;
      }
    }

    return candidate;
  }
};

旋转数组

Mon, 14 Apr 2025 00:00:00 GMT

分析

这题其实还算比较简单。令当前位置为 $i$，数组长度为 $n$，目标位置为 $j$。那么只需要知道 $j = (i + k) % n$ 就能利用一个辅助数组快速写出一个空间复杂度为 $O(N)$ 的解法。若想不出，也可以向我一开始那样通过两个循环先将需要往前移动的数放入数组，然后再利用 $j = n - i$ 来将剩余元素复制到新数组中。

不过，综合时间复杂度和空间复杂度的情况，这题最优解法为翻转三次数组。第一次翻转整个数组。此时数组将以倒序方式排列。随后依次翻转 $[0, k-1], [k, n]$ 区间的元素。此时所有元素位置均已达目标位置。

解答

class Solution {
private:
  void reserve(vector<int> &nums, int start, int end) {
    while (start < end)
      swap(nums[start++], nums[end--]);
  }

public:
  void rotate(vector<int> &nums, int k) {
    k %= nums.size();
    reserve(nums, 0, nums.size() - 1);
    reserve(nums, 0, k - 1);
    reserve(nums, k, nums.size() - 1);
  }
};

移除元素2

Sun, 13 Apr 2025 00:00:00 GMT

分析

这题核心思想在于快慢指针开始的位置和比较位置。当我们从 0 开始时，对于 $[0,0,1,1,1]$ 以及 $[0,0,0,1,1]$，我们只能不断修改判断条件去满足这种避免情况。但如果我们从 2 开始，则只需要判断 slow - 2 != fast 的情况即可。

解答

class Solution {
public:
  int removeDuplicates(vector<int> &nums) {
    auto n = nums.size();
    if (n < 2)
      return n;
    auto slow = 2;

    for (auto fast = 2; fast < n; ++fast) {
      if (nums[fast] != nums[slow - 2]) {
        nums[slow++] = nums[fast];
      }
    }

    return slow;
  }
};

移除元素

Fri, 28 Mar 2025 00:00:00 GMT

分析

这题的核心就是快慢指针，思路本身并不复杂。

我们可以取两个指针，慢指针用于逐个读取元素，快指针在 nums[fast] = val 时跳过。然后我们仅需返回 slow 的值。这样一来时间复杂度为 $O(N)$，空间复杂度为 $O(1)$。

解答

class Solution {
public:
  int removeElement(vector<int> &nums, int val) {
    auto slow = 0;

    for (auto fast = 0; fast < nums.size(); ++fast) {
      if (nums[fast] != val)
        nums[slow++] = nums[fast];
    }

    return slow;
  };
};

合并两个有序数组

Thu, 27 Mar 2025 00:00:00 GMT

分析

这题一眼就能看出要用双指针，不过如何灵活运用就是另外一回事了。

我首先想到的是创建一个新的数组，然后利用两层循环逐个比较。这种暴力做法显然不是最优解，光时间复杂度就已经达到了 $O(m\times n)$。此时问题自然而然地集中在如何合并成一个循环上。该如何合并呢？经过提示不难想出我们可以利用已排列数组这个特性，通过比较 p1、p2 所指向的值，从而有选择地插入。这样下来，时间复杂度被压缩到 $O(m + n)$ ，空间复杂度为 $O(m + n)$。

还能不能进一步优化呢？

仔细观察题意，不难看出 nums1 的总长度为 m + n，其后半部分预留了足够空间用于合并结果。再回想下我们上一个解法中，创建一个新数组是为了避免值被覆盖。那如果我们从后面开始逆序遍历，就可以优先填写最终数组的尾部，因此即使覆盖 nums1 中原有元素，也不会影响尚未比较的内容。[^1] 我们仅需要再添加一个指针 tail 用于存储 m + n - 1 ，让其分别与 $m$、$n$ 比较即可。由于这是从后面开始遍历，所以开始值与结束条件我们也需要变换。此时，空间复杂度压缩到了 $O(1)$。

在这基础上，我们可以做一些小优化：由于当 p2 < 0 时，nums2 已经全部合并完成，所以我们实际上只需要继续判断 p2 >= 0 的情况即可。在这样的情况下，我们也无需在控制语句中额外判断 p1 < 0 之外的冗余分支。这能让内存占用进一步减少，运行速度变得更快。

解答

class Solution {
public:
  void merge(vector<int> &nums1, int m, vector<int> &nums2, int n) {
    auto p1 = m - 1;
    auto p2 = n - 1;
    auto tail = m + n - 1;

    while (p2 >= 0) {
      if (p1 >= 0 && nums1[p1] > nums2[p2])
        nums1[tail--] = nums1[p1--];
      else
        nums1[tail--] = nums2[p2--];
    }
  }
};

脚注

[^1]: 严谨证明可以看 LeetCode 官方

Lorem Ipsum

Thu, 01 Jan 1970 00:00:00 GMT

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin est nisi, sagittis eget enim a, pulvinar vestibulum ex. Maecenas nec dui ac arcu placerat aliquet at vitae massa. In auctor quam ac erat ornare, vitae pharetra risus aliquet. Aliquam quis laoreet erat. Fusce id efficitur est. Nullam non elit finibus, malesuada dui vitae, condimentum mauris. Praesent euismod turpis vitae neque bibendum molestie. Etiam dignissim vitae metus eu placerat. Ut orci mauris, lacinia vitae nibh sit amet, imperdiet rhoncus orci. Nullam commodo leo felis, et congue libero tincidunt vitae. Mauris quis blandit tortor. Aliquam ornare justo lectus, vel tincidunt magna venenatis quis. Integer vitae vehicula diam. Nullam sit amet quam nec felis pretium auctor eu sed ipsum. Phasellus metus felis, semper ac sodales id, varius nec quam. Ut et justo ut tellus porta volutpat a quis lorem.

Vivamus eu elit quis erat pulvinar dictum iaculis a risus. Sed eleifend a magna at pretium. Proin finibus consequat sem, sed ultrices est vulputate quis. Quisque dapibus nisi est, eu eleifend lectus ultrices ac. Nunc quis tortor molestie, euismod lacus id, pharetra nunc. Aenean a varius odio, ut accumsan nulla. Ut pharetra mollis placerat. Integer at neque tempor erat condimentum pellentesque non id nibh. Curabitur quis lacus a nisi eleifend hendrerit. Proin quam sem, iaculis vitae velit in, finibus lacinia eros. Nulla tellus sapien, rutrum nec malesuada quis, suscipit ultricies ligula.

Sed tortor nisi, pulvinar quis erat ut, malesuada porta velit. Maecenas nec ligula nec est convallis eleifend eu non velit. Quisque eget sapien a arcu bibendum ullamcorper. Nulla facilisi. In a consequat dolor. Morbi commodo id neque porttitor dignissim. Etiam et orci in velit semper dapibus. In a tellus ut ante congue semper ac ut justo. Cras vitae odio vehicula, dapibus urna vel, tincidunt dui. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Suspendisse id leo volutpat, mollis enim ac, sollicitudin leo. Phasellus eu volutpat enim, nec auctor metus. Fusce ac libero vehicula, faucibus sapien vitae, congue tortor. Suspendisse euismod magna eget ipsum tristique, sed luctus dui dapibus.

Donec quis ligula hendrerit, tincidunt dolor nec, sollicitudin quam. Fusce tristique ante ut mi commodo posuere. Fusce porta interdum erat, id condimentum felis condimentum ut. Aliquam nulla risus, tempor a enim vitae, tincidunt gravida turpis. Quisque luctus lectus vel mauris sagittis, vel suscipit ligula dignissim. Sed arcu justo, consequat et est eget, sollicitudin faucibus justo. Sed hendrerit eleifend varius. Interdum et malesuada fames ac ante ipsum primis in faucibus. Vivamus ullamcorper et lectus ut pellentesque. Sed porttitor nisi vel dolor ullamcorper scelerisque. Aliquam tempus ut dui at rhoncus.

Ut lacinia libero vehicula nisl maximus pretium. Aenean posuere in ligula et posuere. Phasellus molestie nisl posuere, iaculis dolor ac, lacinia orci. Morbi sed sapien tellus. Donec id imperdiet orci, in porta erat. Proin at purus luctus, suscipit lorem pretium, consectetur arcu. Proin sollicitudin nulla ut massa feugiat finibus. Nam sagittis tincidunt elit at lobortis. Fusce fermentum erat in luctus consequat. Quisque vehicula dolor vel purus consectetur, nec ultrices nisi vestibulum. Maecenas a erat orci. Curabitur bibendum nisl in lacus ultricies suscipit.