Prefix Sum on Hang Zhang

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

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

Product of Array Except Self

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

238. 除自身以外数组的乘积

算法

前缀积数组 pre：
- pre[i] 表示 nums[0] 到 nums[i - 1] 的乘积
- 用于保存当前元素之前所有元素的乘积
后缀积变量 sub：
- 在第二次遍历时，通过一个变量动态记录从右到左的乘积（即 nums[i + 1] 到 nums[n - 1]的乘积）
- 每次更新 pre[i] 为 pre[i] * sub（计算结果数组），并更新 sub

复杂度分析

前缀积遍历一次，后缀积遍历一次，时间复杂度为 O(n)
使用了一个前缀积数组和一个后缀积变量，空间复杂度为 O(n)

C++ 代码

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

        // 初始化前缀积数组
        std::vector<int> pre(n, 1);
        for (int i = 1; i < n; ++ i)
            pre[i] = pre[i - 1] * nums[i - 1];

        // 动态计算后缀积并更新结果
        int sub = 1;
        for (int i = n - 1; i >= 0; -- i)
        {
            pre[i] *= sub;
            sub *= nums[i];
        }

        return pre;
    }
};

Python 代码

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
      n = len(nums)
      pre = [1] * n
      for i in range(1, n):
        pre[i] = pre[i - 1] * nums[i - 1]

      suffix = 1
      for i in range(n - 1, -1, -1):
        pre[i] *= suffix
        suffix *= nums[i]

      return pre

Go 代码

func productExceptSelf(nums []int) []int {
  n := len(nums)
  pre := make([]int, n)
  for i, _ := range pre {
    pre[i] = 1
  }

  for i := 1; i < n; i += 1 {
    pre[i] = pre[i - 1] * nums[i - 1]
  }

  suffix := 1
  for i := n - 1; i >= 0; i -= 1 {
    pre[i] *= suffix
    suffix *= nums[i]
  }

  return pre
}

subarraySum

Tue, 26 Nov 2024 00:00:00 +0000

560. 和为k的子数组

算法

定义前缀和：
- 用 sum 表示从数组起点到当前位置的元素总和
- 任意连续子数组的和可以通过前缀和的差来计算：sum[i] - sum[j] = k => sum[i] - k = sum[j]
使用哈希表存储前缀和出现的次数：
- 哈希表 hash 的键表示前缀和的值，值表示该前缀和出现的次数
- 初始状态下，将前缀和 0 的计数置为 1（代表从起点到当前位置的子数组和可能为 k ）
遍历数组，动态更新结果：
- 遍历数组中的每个元素，将当前值累加到 sum
- 检查 hash 中是否存在键 sum - k：
  - 若存在，说明从某个之前的位置到当前的位置的子数组和为 k ，将其对应的次数累加到结果 res 中
- 更新 hash，增加当前前缀和 sum 的计数
返回结果：
- 遍历结束后，结果 res 即为和为 k 的子数组个数

复杂度分析

时间复杂度

遍历数组：O(n)，其中 n 是数组的长度
哈希表操作：平均时间复杂度为 O(1)
总时间复杂度：O(n)

空间复杂度

使用了哈希表存储前缀和及其次数，空间复杂度为 O(n)，其中 n 是数组的长度

C++ 代码

class Solution
{
public:
    int subarraySum(vector<int>& nums, int k)
    {
        std::unordered_map<int, int> hash; // 存储前缀和及其出现次数
        int res = 0, sum = 0;

        hash[0] = 1; // 初始化前缀和 0 的计数为 1

        for (int num : nums)
        {
            sum += num;            // 更新前缀和
            res += hash[sum - k];  // 检查是否存在前缀和满足条件
            ++ hash[sum];           // 更新当前前缀和的计数
        }

        return res;
    }
};

Python 代码

class Solution:
  def subarraySum(self, nums: List[int], k: int) -> int:
    res, prefix_sum = 0, 0
    freq = {}
    freq[0] = 1
    for x in nums:
      prefix_sum += x

      if prefix_sum - k not in freq:
        freq[prefix_sum - k] = 0

      res += freq[prefix_sum - k]

      if prefix_sum not in freq:
        freq[prefix_sum] = 0

      freq[prefix_sum] += 1
    return res

Go 代码

func subarraySum(nums []int, k int) int {
  res, prefix_sum := 0, 0
  freq := make(map[int]int)
  freq[0] = 1
  for _, x := range nums {
    prefix_sum += x
    res += freq[prefix_sum - k]
    freq[prefix_sum] += 1
  }
  return res
}

JavaScript 代码

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var subarraySum = function (nums, k) {
  let res = 0,
    prefix_sum = 0;
  let freq = new Map();
  freq.set(0, 1);
  for (let x of nums) {
    prefix_sum += x;
    if (freq.has(prefix_sum - k)) {
      res += freq.get(prefix_sum - k);
    }
    freq.set(prefix_sum, (freq.get(prefix_sum) || 0) + 1);
  }
  return res;
};