Double Pointer on Hang Zhang

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)

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

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

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

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

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

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; // 返回总代价
    }
};

Max Consecutive Ones

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

485. 最大连续1的个数

分析

遍历数组 nums ，逐一检查每个元素：
- 如果当前元素是 0，跳过，继续处理下一个元素
- 如果当前元素是 1，启动一个内部循环计算当前连续 1 的长度
记录每次计算到的连续 1 的长度，用变量 res 保持记录最大值
在外部循环中，将索引移动到连续 1 的区间结束位置，避免重复计算

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums)
    {
        int res = 0; // 最大连续 1 的长度
        for (int i = 0; i < nums.size(); ++i) // 遍历数组
        {
            if (nums[i] == 0) // 如果当前是 0，跳过
                continue;

            int j = i + 1; // 进入内部循环，计算连续 1 的长度
            while (j < nums.size() && nums[j] == 1)
                ++j;

            res = std::max(res, j - i); // 更新最大连续长度
            i = j; // 将索引移动到连续 1 的区间结束位置
        }
        return res;
    }
};

Is Subsequence

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

392. 判断子序列

分析

初始化指针：
- 用指针 i 表示字符串 s 的匹配位置，初始为 0
遍历字符串 t：
- 遍历字符串 t 中的每个字符 c
- 如果 t 中当前字符与 s[i] 相同，则将指针 i 向后移动
判断结果：
- 遍历完成后，若 i == s.size()，说明 s 的所有字符都在 t 中按照顺序找到，返回 true
- 否则返回 false

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    bool isSubsequence(string s, string t)
    {
        int i = 0; // 指针 i 表示当前匹配到 s 的第几个字符
        for (char c : t) // 遍历 t 中的每个字符
        {
            // 如果当前字符与 s[i] 匹配，则 i 前进
            if (i < s.size() && s[i] == c)
                i ++;
        }

        // 如果所有 s 的字符都匹配到了，返回 true
        return i == s.size();
    }
};

String Compression

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

443. 压缩字符串

分析

遍历字符数组：
- 使用两个指针，一个 i 遍历原数组，另一个 k 表示压缩后字符存储的位置
记录连续重复字符：
- 每次找到一组连续重复的字符，记录其长度 len
压缩字符组：
- 将字符写入结果数组。
- 如果长度 len > 1，将其转为字符串形式逐个写入，需要使用 std::reverse 处理因低位数字先写入导致的顺序问题
更新指针：
- 将指针 i 移动到下一个未处理的字符位置
返回结果：
- 最终返回数组新长度 k

时间复杂度

遍历整个数组一次，时间复杂度为 O(n)

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    int compress(vector<char>& s) 
    {
        int k = 0; // 压缩后存储字符的位置
        for (int i = 0; i < s.size(); ++i)
        {
            int j = i + 1;
            // 找到连续重复字符的结尾位置
            while (j < s.size() && s[i] == s[j])
                ++j;

            // 写入当前字符
            s[k++] = s[i];

            // 计算连续字符的长度
            int len = j - i;

            // 如果长度大于 1，将其转为字符串写入数组
            if (len > 1)
            {
                int t = k; // 用于临时存储数字的开始位置
                while (len)
                {
                    s[t++] = '0' + len % 10;
                    len /= 10;
                }
                // 将数字部分反转以正确顺序写入
                std::reverse(s.begin() + k, s.begin() + t);
                k = t; // 更新压缩后的位置
            }

            // 更新 i 到当前字符组的结束位置
            i = j - 1;
        }    
        return k; // 返回压缩后的数组长度
    }
};

Reverse Words in a String

Fri, 20 Dec 2024 00:00:00 +0000

151. 反转字符串中的单词

分析

去除多余空格：
- 遍历字符串，将所有单词移动到前面，同时移除多余的空格
- 用一个变量 k 表示当前写入位置
逐个反转单词：
- 每次遇到非空格字符时，确定单词的起始位置 i
- 继续遍历直到单词结束，将单词拷贝到字符串前面
- 对该单词的字符进行局部反转
- 在单词末尾添加空格，准备下一个单词的处理
清理末尾多余空格：
- 如果最后多余了一个空格，则将其删除
整体反转字符串：
- 将整个字符串反转，得到单词顺序颠倒的最终结果

时间复杂度

遍历字符串三次：去除多余空格 O(n)、单词局部反转 O(n)、整体反转 O(n)

总时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    string reverseWords(string s)
    {
        int k = 0; // 表示当前写入位置
        for (int i = 0; i < s.size(); ++i)
        {
            // 跳过空格
            if (s[i] == ' ')
                continue;

            // 找到单词的起始位置
            int j = i, t = k;
            while (j < s.size() && s[j] != ' ')
                s[t++] = s[j++];

            // 反转单词
            std::reverse(s.begin() + k, s.begin() + t);

            // 在末尾添加一个空格
            s[t++] = ' ';
            k = t; // 更新写入位置
            i = j; // 跳过当前单词
        }

        // 删除末尾多余的空格
        if (k > 0)
            --k;
        s.erase(s.begin() + k, s.end());

        // 整体反转字符串
        std::reverse(s.begin(), s.end());

        return s;
    }
};

Can Place Flowers

Thu, 19 Dec 2024 00:00:00 +0000

605. 种花问题

分析

寻找连续空地：
- 遍历数组时，如果遇到值为 0 的位置，开始寻找连续空地的终点
- 空地的长度是终点索引减去起点索引
边界特殊处理：
- 如果空地段位于数组的开头或结尾，由于没有相邻的种植限制，可以额外种植一朵花
更新累积种植数量：
- 根据空地长度计算可种植的花数，并累积到 res 中
- 如果 res 已达到或超过目标值 n，提前返回 true，减少不必要的计算

时间复杂度

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    bool canPlaceFlowers(vector<int>& flowerbed, int n)
    {
        if (!n) return true; // 如果需要种植的花为 0，直接返回 true。
        int res = 0; // 已种植的花数。

        for (int i = 0; i < flowerbed.size(); ++i)
        {
            if (flowerbed[i]) // 当前位置已经种植了花，跳过。
                continue;

            int j = i;
            // 找到连续空地的终点。
            while (j < flowerbed.size() && flowerbed[j] == 0)
                ++j;

            // 计算连续空地的长度。
            int k = j - i - 1;

            // 边界处理：如果在开头或结尾，空地长度增加 1。
            if (!i)
                k += 1;
            if (j == flowerbed.size())
                k += 1;

            // 根据种植规则计算可以种植的花数。
            res += k / 2;

            // 如果累计种植的花数已达到或超过 n，返回 true。
            if (res >= n)
                return true;

            // 跳过当前检查的空地段。
            i = j;
        }

        // 如果遍历结束仍未满足 n，返回 false。
        return false;
    }
};

Reverse Vowels of a String

Thu, 19 Dec 2024 00:00:00 +0000

345. 反转字符串中的元音字母

分析

定义元音集合：
- 使用一个哈希集合存储所有的元音字母，用于快速判断一个字符是否是元音
双指针法：
- 初始化两个指针：i 指向字符串的起始位置，j 指向字符串的末尾位置
- 使用双指针从两端向中间遍历，找到最近的两个元音字母，交换它们的位置
具体步骤：
- 如果 s[i] 不是元音，则 i 向右移动
- 如果 s[j] 不是元音，则 j 向左移动
- 当 s[i] 和 s[j] 都是元音时，交换它们，并同时移动两个指针
- 重复上述过程，直到两个指针相遇或交错

时间复杂度

双指针最多遍历字符串一次，每次操作的时间为 O(1)

总时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    string reverseVowels(string s)
    {
        // 定义元音字母集合
        std::unordered_set<char> hash = {
            'a', 'e', 'i', 'o', 'u',
            'A', 'E', 'I', 'O', 'U'
        };

        // 双指针初始化
        for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
        {
            // 左指针寻找元音
            while (i < j && !hash.count(s[i]))
                ++i;
            // 右指针寻找元音
            while (i < j && !hash.count(s[j]))
                --j;
            // 交换两个元音字母
            std::swap(s[i], s[j]);
        }

        return s; // 返回结果字符串
    }
};

Merge Strings Alternately

Wed, 18 Dec 2024 00:00:00 +0000

1768. 交替合并字符串

时间复杂度

时间复杂度 O(max(n, m))

空间复杂度

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

C++代码

class Solution
{
public:
    string mergeAlternately(string word1, string word2)
    {
      std::string res;
      int n = word1.size(), m = word2.size();
      int i = 0, j = 0;
      while (i < n || j < m)
      {
        if (i < n) res += word1[i ++ ];
        if (j < m) res += word2[j ++ ];
      }
      return res;
    }
};

Jupm Game II

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

45. 跳跃游戏II

算法

核心思想：使用贪心算法模拟跳跃过程，按层次遍历的思想解决问题
- 当前位置的覆盖范围：表示当前跳跃次数能够到达的最远位置
- 下一次跳跃的覆盖范围：表示增加一次跳跃后能够到达的最远位置
关键变量：
- cur：当前处理的位置。
- dist：当前跳跃次数能够到达的最远位置。
- next：下一跳能够到达的最远位置。
跳跃过程：
- 初始化跳跃次数 res = 0，起点为 cur = 0
- 在当前跳跃的范围内（从 cur 到 dist），计算下一跳的最远位置 next
- 当 dist 超过或等于数组最后一个位置时，结束跳跃。
步数增加：
- 每遍历完当前跳跃的范围时，更新到下一跳的最远位置 dist = next，并增加跳跃次数 res

复杂度分析

每个位置最多访问一次，因此时间复杂度为 O(n)
空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    int jump(vector<int>& nums)
    {
        int res = 0;       // 跳跃次数
        int cur = 0;       // 当前处理的位置
        int dist = 0;      // 当前跳跃的覆盖范围
        while (dist < nums.size() - 1)
        {
            int next = 0;  // 下一跳的覆盖范围
            // 遍历当前跳跃范围
            while (cur <= dist)
            {
                next = std::max(next, cur + nums[cur]);  // 更新下一跳的最远范围
                ++cur;
            }
            dist = next;   // 更新跳跃范围
            ++res;         // 跳跃次数加一
        }
        return res;
    }
};

Python 代码

class Solution:
    def jump(self, nums: List[int]) -> int:
      res = 0
      dist, cur = 0, 0
      while dist < len(nums) - 1:
        next_dist = 0
        while cur <= dist:
          next_dist = max(next_dist, cur + nums[cur])
          cur += 1
        dist = next_dist
        res += 1
      return res

Go 代码

func jump(nums []int) int {
  res := 0
  dist, cur := 0, 0
  for dist < len(nums) - 1 {
    next := 0
    for cur <= dist {
      next = max(next, cur + nums[cur])
      cur += 1
    }
    dist = next
    res += 1
  }
  return res
}

Partition Lables

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

763. 划分字母区间

分析

记录每个字母的最远出现位置：
- 遍历字符串，记录每个字符最后一次出现的索引，存储在哈希表 hash 中
划分片段：
- 使用变量 start 表示当前片段的起始位置，end 表示当前片段中字符的最远位置
- 遍历字符串时，动态更新当前片段的最远位置 end
- 当当前索引 i 等于 end 时，表示当前片段结束，将片段长度加入结果数组 res
更新起点：
- 划分一个片段后，将 start 更新为 i + 1，准备划分下一个片段

时间复杂度

记录最远位置: O(n)，需要遍历一次字符串记录字符的最远位置
划分片段: O(n)，第二次遍历字符串进行片段划分

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

空间复杂度

哈希表 hash 的空间复杂度为 O(k)，其中 k 是字符集大小（对于英文字母，k < 26）
结果数组 res 需要额外存储片段长度，空间复杂度为 O(p)，其中 p 是片段数量

总体空间复杂度为 O(k + p)

C++代码

class Solution
{
public:
    vector<int> partitionLabels(string s)
    {
        // 记录每个字符的最远出现位置
        std::unordered_map<char, int> hash;
        for (int i = 0; i < s.size(); ++i)
            hash[s[i]] = i;

        std::vector<int> res; // 存储结果
        int start = 0, end = 0;

        for (int i = 0; i < s.size(); ++i)
        {
            // 更新当前片段的最远边界
            end = std::max(end, hash[s[i]]);

            // 当前片段结束
            if (i == end)
            {
                res.push_back(end - start + 1); // 保存片段长度
                start = end = i + 1;           // 更新起点，准备下一个片段
            }
        }

        return res;
    }
};

Find the Duplicate Number

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

287. 寻找重复数

分析

将问题抽象为一个带环的链表问题：

数组中的每个元素都可以看作指向下一个索引的指针：元素的值 nums[i] 指向索引 nums[i]
因为数组中有重复的数字，这意味着某些索引会形成一个环。我们需要找到这个环的入口点，即重复的数字

利用 Floyd 判圈算法（龟兔赛跑算法）可以高效解决这个问题：

阶段 1：找到快慢指针的相遇点
- 定义两个指针：慢指针 a 每次移动一步，快指针 b 每次移动两步
- 两个指针一定会在环中相遇。
阶段 2：找到环的入口点
- 将其中一个指针 a 重新指向起点 0 ，另一个指针 b 保持在相遇点
- 两个指针每次都移动一步，相遇时的点即为环的入口点，也就是重复的数字

时间复杂度

快慢指针每次只移动一步或两步，最多经过两次遍历（一次寻找环，一次定位入口），时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int findDuplicate(vector<int>& nums)
    {
        int a = 0, b = 0;  // 初始化快慢指针
        while (true)
        {
            a = nums[a];       // 慢指针每次走一步
            b = nums[b];       // 快指针第一次走一步
            b = nums[b];       // 快指针第二次走一步

            // 快慢指针相遇，退出循环
            if (a == b)
            {
                a = 0;         // 慢指针从起点开始
                while (a != b) // 两指针同步移动
                {
                    a = nums[a];
                    b = nums[b];
                }
                return a;      // 相遇点即为环入口，即重复数字
            }
        }
        return -1;  // 理论上不可能到达这里
    }
};

Sort Colors

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

75. 颜色分类

分析

经典的荷兰国旗问题，通过双指针和单次遍历的方式完成排序

将数组分为三个区域：

左区域（存放红色 0 的区域）
右区域（存放蓝色 2 的区域）
中间区域（存放白色 1 的区域）

使用三个指针：
- i: 指向左区域的边界
- j: 当前正在遍历的元素位置
- k: 指向右区域的边界
初始化 i = 0、j = 0、k = n-1
遍历数组，判断 \text{nums}[j] ：
- 如果是 1（白色），直接跳过，j++
- 如果是 0（红色），将 nums[j] 和 nums[i] 交换，i++, j++
- 如果是 2（蓝色），将 nums}[j] 和 nums}[k] 交换，k–- （注意：此时 j 不前进，继续检查新的 nums[j]
遍历结束后，数组即为排序后的结果

时间复杂度

整个数组只遍历了一次，时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    void sortColors(vector<int>& nums)
    {
        int i = 0, j = 0, k = nums.size() - 1; // 初始化指针
        while (j <= k) // 遍历直到中间指针超过右边界
        {
            if (nums[j] == 1) // 当前是白色，跳过
                ++j;
            else if (nums[j] == 0) // 当前是红色，交换到左区域
            {
                std::swap(nums[i], nums[j]);
                ++i, ++j;
            }
            else // 当前是蓝色，交换到右区域
            {
                std::swap(nums[j], nums[k]);
                --k;
            }
        }
    }
};

Longest Palindromic Substring

Fri, 13 Dec 2024 00:00:00 +0000

5. 最长回文子串

分析

中心扩展思想：
- 回文的中心可以是一个字符（如 aba 的中心是 b），也可以是两个字符之间（如 abba 的中心是 bb）
- 遍历字符串的每一个字符（和每一个字符间隙）作为中心，向两侧扩展判断是否为回文子串
具体步骤：
- 枚举每一个可能的中心：
- 单字符中心：如字符 a
- 双字符中心：如字符对 aa
- 每次以当前中心向两侧扩展，直到遇到不相等的字符或边界
- 记录当前最长的回文子串，并与之前记录的结果进行比较，更新最长子串

时间复杂度

遍历字符串每个字符 O(n)，每次从中心向外扩展最多 O(n)，总体时间复杂度为 O(n^2)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    string longestPalindrome(string s)
    {
        // 初始化结果变量
        std::string res;

        // 遍历字符串的每一个字符，尝试以其为中心扩展
        for (int i = 0; i < s.size(); ++i)
        {
            // 第一种情况：中心是单个字符
            int l = i - 1, r = i + 1;
            while (l >= 0 && r < s.size() && s[l] == s[r])
                --l, ++r;
            // 更新最长回文子串
            if (res.size() < r - l - 1)
                res = s.substr(l + 1, r - l - 1);

            // 第二种情况：中心是两个字符之间
            l = i, r = i + 1;
            while (l >= 0 && r < s.size() && s[l] == s[r])
                --l, ++r;
            // 更新最长回文子串
            if (res.size() < r - l - 1)
                res = s.substr(l + 1, r - l - 1);
        }

        // 返回最长回文子串
        return res;
    }
};

Push Dominoes

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

838. 推多米诺

分析

字符串首尾哨兵添加：
- 为简化边界条件处理，在字符串首部添加 'L'，尾部添加 'R'，变成 dominoes = 'L' + dominoes + 'R'
- 这样首尾骨牌始终有确定的受力方向
预处理左右最近的受力源：
- 定义两个数组 l 和 r：
  - l[i] 表示索引 i 左侧最近的 'L' 的位置；
  - r[i] 表示索引 i 右侧最近的 'R' 的位置
- 遍历计算：
  - 从左向右遍历填充 l，记录每个位置最近的 'L'；
  - 从右向左遍历填充 r，记录每个位置最近的 'R'
根据受力平衡更新状态：
- 遍历每个位置，根据 l[i] 和 r[i] 的值判断受力方向：
  - 如果 dominoes[l[i]] == 'L' && dominoes[r[i]] == 'R'，受力平衡，骨牌保持竖立 '.'；
  - 如果两侧的受力方向一致，骨牌倒向对应方向；
  - 如果受力方向不同且距离不同，骨牌倒向距离近的一侧；
  - 如果受力方向不同且距离相等，骨牌保持竖立 '.'
移除哨兵：
- 返回字符串 dominoes.substr(1, n - 2)，移除首尾哨兵

时间复杂度

遍历三次字符串：分别计算 l 和 r 的值，以及最终更新 dominoes 的状态

总时间复杂度 O(n)

空间复杂度

空间复杂度：O(n)

C++代码

class Solution
{
public:
    string pushDominoes(string dominoes)
    {
      // 添加哨兵
      dominoes = 'L' + dominoes + 'R';
      int n = dominoes.size();
      std::vector<int> l(n), r(n);

      // 记录左侧最近的'L'
      int pos = 0;
      for (int i = 1; i < n; ++i)
      {
        if (dominoes[i] != '.')
          pos = i; // 更新最近的'L'或'R'
        l[i] = pos; // 保存当前位置左侧的最近受力源
      }

      // 记录右侧最近的'R'
      for (int i = n - 1; i >= 0; --i)
      {
        if (dominoes[i] != '.')
          pos = i; // 更新最近的'L'或'R'
        r[i] = pos; // 保存当前位置右侧的最近受力源
      }

      // 判断骨牌最终的状态
      for (int i = 0; i < n; ++i)
      {
        if (dominoes[l[i]] == 'L' && dominoes[r[i]] == 'R')
        {
          dominoes[i] = '.'; // 平衡受力
        }
        else if (dominoes[l[i]] == 'L' && dominoes[r[i]] == 'L')
        {
          dominoes[i] = 'L'; // 受左侧'L'影响
        }
        else if (dominoes[l[i]] == 'R' && dominoes[r[i]] == 'R')
        {
          dominoes[i] = 'R'; // 受右侧'R'影响
        }
        else
        {
          // 受不同方向影响，根据距离判断
          if (i - l[i] < r[i] - i)
            dominoes[i] = 'R';
          else if (i - l[i] > r[i] - i)
            dominoes[i] = 'L';
          else
            dominoes[i] = '.';
        }
      }

      // 移除首尾哨兵
      return dominoes.substr(1, n - 2);
    }
};

linkedListCycleII

Fri, 29 Nov 2024 00:00:00 +0000

142. 环形链表II

分析

判断链表是否有环
- 设置两个指针 slow 和 fast，初始都指向链表头节点 head
- 快指针每次移动两步，慢指针每次移动一步
- 如果快指针追上慢指针，说明链表中有环；否则，如果快指针或其下一节点为空，则链表无环
找到环的起始节点
- 当快慢指针相遇时，将慢指针重置为链表头节点 head
- 快指针保持在相遇位置
- 两个指针每次都向前移动一步，当两者再次相遇时，相遇点即为环的起始节点

数学推导

假设：

链表头到环入口节点的距离为 a
环入口到相遇点的距离为 b
相遇点到环入口的距离为 c

快指针比慢指针速度快一倍，因此：2(a + b) = a + b + n(b + c)（ n 为快指针在环中绕的圈数），化简得：a = c + (n - 1)(b + c)

这表明：

从链表头节点到环入口的距离 a 等于从相遇点沿环走回入口的距离 c
因此，当两个指针一个从链表头开始，一个从相遇点开始，每次移动一步，最终会在环的起始节点相遇

时间复杂度

快慢指针遍历链表一次即可确定是否有环，以及找到环的起始节点，时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        // 链表为空或只有一个节点，不可能有环
        if (!head || !head->next)
            return nullptr;

        ListNode *slow = head, *fast = head;

        // 判断链表是否有环
        while (fast)
        {
            slow = slow->next;          // 慢指针走一步
            fast = fast->next;          // 快指针走一步
            if (fast)
                fast = fast->next;      // 快指针再走一步

            if (slow == fast)           // 快慢指针相遇
            {
                // 找到环的起始节点
                slow = head;            // 慢指针回到链表头
                while (slow != fast)    // 两指针相遇即为环入口
                {
                    slow = slow->next;
                    fast = fast->next;
                }
                return fast;
            }
        }

        return nullptr; // 无环
    }
};

rotateArray

Wed, 27 Nov 2024 00:00:00 +0000

189. 轮转数组

分析

确定实际轮转次数：
- 如果 k 大于数组长度 n，轮转后的结果与 k % n 次轮转相同
- 因此需要先对 k 取模：k %= n
三次反转法：
- 整体反转：将整个数组反转，这样后 k 个元素会移动到前面
- 前部分反转：将前 k 个元素反转，恢复它们的顺序
- 后部分反转：将剩余的 n-k 个元素反转，恢复它们的顺序

时间复杂度

反转操作：每次反转需要遍历部分数组，整体复杂度为 O(n)

空间复杂度

原地操作：仅使用常数级别的额外空间，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    void rotate(vector<int>& nums, int k)
    {
        int n = nums.size();
        k %= n;  // 计算有效的轮转次数

        // 反转整个数组
        for (int i = 0; i < n / 2; ++i)
            std::swap(nums[i], nums[n - 1 - i]);

        // 反转前 k 个元素
        for (int i = 0; i < k / 2; ++i)
            std::swap(nums[i], nums[k - 1 - i]);

        // 反转后 n-k 个元素
        for (int i = k; i < (n + k) / 2; ++i)
            std::swap(nums[i], nums[n - 1 - i + k]);
    }
};

maxArea

Mon, 25 Nov 2024 00:00:00 +0000

11. 盛最多水的容器

算法

容器的水量由两条垂线的较小高度和它们之间的水平距离决定，公式为：min(height[i], height[j]) * (j - i)

初始时，将左右指针分别置于数组的两端
计算当前两条垂线能容纳的水量，并更新最大水量
移动高度较小的一侧的指针：
- 因为容器的水量由两条垂线的较小高度决定，移动较小高度的一侧可能增加更高的高度，从而得到更大的水量
当左右指针相遇时，遍历结束，最大水量即为结果

复杂度分析

时间复杂度

指针遍历：每次移动一个指针，最多遍历数组一次，时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
    {
public:
    int maxArea(vector<int>& height)
    {
        int res = 0; // 存储最大水量
        int i = 0, j = height.size() - 1; // 初始化左右指针

        while (i < j)
        {
            // 计算当前容器的水量
            res = std::max(res, std::min(height[i], height[j]) * (j - i));

            // 移动高度较小的一侧
            if (height[i] < height[j]) ++ i;
            else -- j;
        }

        return res; // 返回最大水量
    }
};

Python 代码

class Solution:
  def maxArea(self, height: List[int]) -> int:
    i, j = 0, len(height) - 1
    res = 0
    while i < j:
      res = max(res, min(height[i], height[j]) * (j - i));
      if height[i] < height[j]:
        i += 1
      else:
        j -= 1
    return res

Go 代码

func maxArea(height []int) int {
  i, j := 0, len(height) - 1
  res := 0
  for i < j {
    h := 0
    if height[i] < height[j] {
      h = height[i]
    } else {
      h = height[j]
    }

    area := h * (j - i)
    if area > res {
      res = area
    }

    if height[i] < height[j] {
      i ++
    } else {
      j --
    }
  }
  return res
}

JavaScript 代码

/**
 * @param {number[]} height
 * @return {number}
 */
var maxArea = function (height) {
  let i = 0,
    j = height.length - 1;
  let res = 0;

  while (i < j) {
    res = Math.max(res, Math.min(height[i], height[j]) * (j - i));
    if (height[i] < height[j]) {
      i++;
    } else {
      j--;
    }
  }
  return res;
};

moveZeroes

Mon, 25 Nov 2024 00:00:00 +0000

283. 移动零

算法

i 用于记录非零元素的位置
遍历数组时，将非零元素按顺序填入数组前部，并记录当前插入的位置
遍历完成后，数组前部已填满非零元素，后续位置全部填充 0

复杂度分析

时间复杂度

遍历数组一次，时间复杂度为 O(n)
填充零的操作也是 O(n) ，但两者不重叠，总体为O(n)

空间复杂度

使用了两个指针变量，空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    void moveZeroes(vector<int>& nums)
    {
        int i = 0; // 指针 i，用于记录下一个非零元素的位置

        // 1. 遍历数组，将所有非零元素依次放到前部
        for (int num : nums)
        {
            if (num != 0)
            {
                nums[i++] = num; // 将非零元素放入 i 位置，并移动 i
            }
        }

        // 2. 将剩余位置填充为 0
        while (i < nums.size())
        {
            nums[i++] = 0;
        }
    }
};

Python 代码

class Solution:
  def moveZeroes(self, nums: List[int]) -> None:
    i = 0
    for x in nums:
      if x != 0:
        nums[i] = x
        i += 1

    while i < len(nums):
      nums[i] = 0
      i += 1

Go 代码

func moveZeroes(nums []int)  {
  i := 0

  for _, x := range nums {
    if x != 0 {
      nums[i] = x
      i ++
    }
  }

  for i < len(nums) {
    nums[i] = 0
    i ++
  }
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function (nums) {
  let i = 0;

  for (let x of nums) {
    if (x != 0) {
      nums[i++] = x;
    }
  }

  while (i < nums.length) {
    nums[i++] = 0;
  }
};

Three Sum

Fri, 22 Nov 2024 00:00:00 +0000

15. 三数之和

算法

排序数组：
- 首先将数组从小到大排序，方便后续操作
固定一个数，双指针搜索：
- 遍历排序后的数组，用 i 指向当前固定的数
- 在 i 的右侧，使用双指针 j 和 k：
  - j 指向 i + 1
  - k 指向数组末尾
- 检查三数之和：
  - 若三数之和小于 0，说明需要更大的值，移动 j 向右
  - 若三数之和大于 0，说明需要更小的值，移动 k 向左
  - 若三数之和等于 0，记录结果，同时移动 j 和 k 跳过重复值
去重：
- 对于固定数 nums[i]，若 nums[i] = nums[i-1]，跳过当前遍历，避免重复三元组
- 对于 nums[j] 和 nums[k]，在找到一个解后，继续移动跳过相同值

复杂度分析

时间复杂度

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

空间复杂度

使用排序 O(logn) 的额外空间，其余操作在原地完成，空间复杂度为 O(1)

C++ 代码

class Solution
{
public:
    vector<vector<int>> threeSum(vector<int>& nums)
    {
        std::vector<std::vector<int>> res;
        std::sort(nums.begin(), nums.end()); // 对数组进行排序

        for (int i = 0; i < nums.size(); ++i)
        {
            // 跳过重复的固定数
            if (i > 0 && nums[i] == nums[i - 1]) continue;

            // 双指针寻找其他两数
            for (int j = i + 1, k = nums.size() - 1; j < k; ++ j)
            {
                // 跳过重复的第二个数
                if (j > i + 1 && nums[j] == nums[j - 1]) continue;

                // 移动右指针，寻找满足条件的三元组
                while (j < k - 1 && nums[i] + nums[j] + nums[k - 1] >= 0) -- k;

                // 判断当前三数之和是否为零
                if (nums[i] + nums[j] + nums[k] == 0)
                    res.push_back({nums[i], nums[j], nums[k]});
            }
        }

        return res;
    }
};

Python 代码

class Solution:
  def threeSum(self, nums: List[int]) -> List[List[int]]:
    res = []
    nums.sort()
    for i in range(len(nums)):
      if i > 0 and nums[i] == nums[i - 1]:
        continue
      j, k = i + 1, len(nums) - 1
      while j < k:
        if j > i + 1 and nums[j] == nums[j - 1]:
          j += 1
          continue
        while j < k - 1 and nums[i] + nums[j] + nums[k - 1] >= 0:
          k -= 1
        if nums[i] + nums[j] + nums[k] == 0:
          res.append([nums[i], nums[j], nums[k]])
        j += 1
    return res

Go 代码

func threeSum(nums []int) [][]int {
  res := [][]int{}
  sort.Ints(nums)
  for i := 0; i < len(nums); i ++ {
    if i > 0 && nums[i] == nums[i - 1] {
      continue
    }
    for j, k := i + 1, len(nums) - 1; j < k; j ++ {
      if j > i + 1 && nums[j] == nums[j - 1] {
        continue
      }
      for j < k - 1 && nums[i] + nums[j] + nums[k - 1] >= 0 {
        k --
      }
      if nums[i] + nums[j] + nums[k] == 0 {
        res = append(res, []int{nums[i], nums[j], nums[k]})
      }
    }
  }
  return res
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function (nums) {
  let res = [];
  nums.sort((a, b) => a - b);

  for (let i = 0; i < nums.length; i++) {
    if (i > 0 && nums[i] == nums[i - 1]) {
      continue;
    }
    for (let j = i + 1, k = nums.length - 1; j < k; j++) {
      if (j > i + 1 && nums[j] == nums[j - 1]) {
        continue;
      }
      while (j < k - 1 && nums[i] + nums[j] + nums[k - 1] >= 0) {
        k--;
      }
      if (nums[i] + nums[j] + nums[k] == 0) {
        res.push([nums[i], nums[j], nums[k]]);
      }
    }
  }
  return res;
};

Remove Element

Thu, 28 Mar 2024 00:00:00 +0000

27. 移除元素

算法

双指针：

一个读指针（通过范围 for 遍历 nums）
一个写指针 i，用于记录当前应当写入的位置。
每次遇到不等于 val 的元素，就写入当前位置 i 并将 i ++

复杂度分析

时间复杂度：O(n)，每个元素最多被访问一次
空间复杂度：O(1)，只使用了常数额外空间

C++ 代码

class Solution
{
public:
    int removeElement(vector<int>& nums, int val)
    {
        int i = 0; // 写指针
        for (int x : nums)
            if (x != val)
                nums[i ++ ] = x;
        return i;
    }
};

Python 代码

class Solution:
  def removeElement(self, nums: List[int], val: int) -> int:
    i = 0
    for x in nums:
      if x != val:
        nums[i] = x
        i += 1
    return i

Go 代码

func removeElement(nums []int, val int) int {
  i := 0
  for _, x := range nums {
    if x != val {
      nums[i] = x
      i ++
    }
  }
  return i
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function (nums, val) {
  let i = 0;
  for (let x of nums) {
    if (x !== val) {
      nums[i++] = x;
    }
  }
  return i;
};

Remove Duplicates from Sorted Array

Wed, 27 Mar 2024 00:00:00 +0000

26. Remove Duplicates from Sorted Array

分析

用索引 k 记录非重复元素的位置。
判断当前元素 i 是否为第一个元素或是否与前一个元素不等。
如果满足上述条件，将当前元素复制到数组中索引为 k 的位置，然后递增 k。
最后返回索引 k，它表示移除重复元素后的数组长度。

C++代码

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int k = 0;
        for (int i = 0; i < nums.size(); i ++ )
            if (!i || nums[i] != nums[i - 1])
                nums[k ++ ] = nums[i];
        return k;
    }
};

4Sum

Wed, 20 Mar 2024 00:00:00 +0000

18. 4Sum

分析

与三数之和一样，只是这里要枚举两个位置 i 和 j。

C++代码

class Solution {
public:
    typedef long long LL;

    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i ++ ) {
            if (i && nums[i] == nums[i - 1]) continue;
            for (int j = i + 1; j < nums.size(); j ++ ) {
                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
                for (int k = j + 1, l = nums.size() - 1; k < l; k ++ ) {
                    if (k > j + 1 && nums[k] == nums[k - 1]) continue;
                    while (l - 1 > k && (LL)nums[i] + nums[j] + nums[k] + nums[l - 1] >= target) l -- ;
                    if ((LL)nums[i] + nums[j] + nums[k] + nums[l] == (LL)target) {
                        res.push_back({nums[i], nums[j], nums[k], nums[l]});
		            }
                }
            }
        }
        return res;
    }
};

3Sum Closest

Mon, 18 Mar 2024 00:00:00 +0000

16. 3Sum Closest

分析

暴力做法就是三重循环，每种答案枚举一遍，求一个最接近的值。

用双指针优化。先枚举位置i，对每一个位置j，找到一个最小的位置k使得 nums[i] + nums[j] + nums[k] >= target，这样可以得到大于等于target的最小值。并且，当k满足前述条件时，必然有 nums[i] + nums[j] + nums[k - 1] < target，也就可以得到小于target的最大值。每次更新下这两个值即可。

C++代码

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        pair<int, int> res(INT_MAX, INT_MAX);
        for (int i = 0; i < nums.size(); i ++ )
            for (int j = i + 1, k = nums.size() - 1; j < k; j ++ ) {
                while (k - 1 > j && nums[i] + nums[j] + nums[k - 1] >= target) k -- ;
                int s = nums[i] + nums[j] + nums[k];
                res = min(res, make_pair(abs(s - target), s));
                if (k - 1 > j) {
                    s = nums[i] + nums[j] + nums[k - 1];
                    res = min(res, make_pair(target - s, s));
                }
            }
        return res.second;
    }
};

Container With Most Water

Wed, 13 Mar 2024 00:00:00 +0000

11. Container With Most Water

分析

用两个指针i和j分别指向开头和结尾，如果指针i指向的水柱高度较低，则指针i向后移，反之指针j向前移。每移动一次后，求当前指针i和j指向水柱之间的面积，更新一下最大值。

为什么更新出来的值一定是最优解。 i和j最开始在两侧，每次把一个指针向中间靠拢，则一定有一侧指针会先到最优解的位置。假定指针i先到最优解位置，则指针j一定在其最优解位置的右边，并且指针j在到达最优解位置前每次指向的水柱高度严格小于最优解位置的高度。

可以使用反证法证明。如果指针j当前指向的水柱高度大于等于其最优解位置的高度，则能装的水量一定大于最优解，就和最优解位置矛盾。因此，通过上述过程，一定可以遍历出最优解。

C++代码

class Solution {
public:
    int maxArea(vector<int>& height) {
        int res = 0;
        for (int i = 0, j = height.size() - 1; i < j; ) {
            res = max(res, min(height[i], height[j]) * (j - i));
            if (height[i] < height[j]) i ++ ;
            else j -- ;
        }
        return res;
    }
};