LeetCode第325题_和等于k的最长子数组长度-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40263592/article/details/149282912

LeetCode 第325题：和等于k的最长子数组长度

📖 文章摘要

本文详细解析LeetCode第325题"和等于k的最长子数组长度"，这是一道前缀和和哈希表的经典问题。文章提供了前缀和+哈希表的解法，包含C#、Python、C++三种语言实现，配有详细的算法分析和性能对比。适合想要提升前缀和和哈希表应用能力的程序员。

核心知识点： 前缀和、哈希表、子数组
难度等级： 中等
推荐人群： 具有基础算法知识，想要提升数组和哈希表操作能力的程序员

题目描述

给定一个数组 nums 和一个目标值 k，找到和等于 k 的最长连续子数组的长度。如果不存在任意一个符合要求的子数组，则返回 0。

示例

示例 1：

输入: nums = [1, -1, 5, -2, 3], k = 3
输出: 4
解释: 子数组 [1, -1, 5, -2] 和等于 3，且长度最大。

示例 2：

输入: nums = [-2, -1, 2, 1], k = 1
输出: 2
解释: 子数组 [-1, 2] 和等于 1，且长度最大。

提示

1 <= nums.length <= 2 * 10^5
-10^4 <= nums[i] <= 10^4
-10^9 <= k <= 10^9

解题思路

方法：前缀和 + 哈希表

使用前缀和和哈希表来优化查找过程。

关键点：

计算前缀和数组
使用哈希表存储前缀和第一次出现的位置
当前前缀和减去目标值k在哈希表中存在时更新最大长度
只保存前缀和第一次出现的位置以获得最长子数组

具体步骤：

初始化哈希表和前缀和变量
遍历数组，累加前缀和
检查当前前缀和是否等于k
检查前缀和减k是否存在于哈希表中
更新最大长度
如果当前前缀和不在哈希表中则添加

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

图解思路

前缀和计算过程表

索引	数组值	前缀和	目标差值(sum-k)	最大长度	说明
0	1	1	-2	0	初始状态
1	-1	0	-3	0	更新前缀和
2	5	5	2	0	更新前缀和
3	-2	3	0	4	找到和为k的子数组
4	3	6	3	4	维持最大长度

哈希表状态表

前缀和	首次出现位置	更新时机
0	-1	初始化
1	0	遍历位置0
0	1	遍历位置1
5	2	遍历位置2
3	3	遍历位置3
6	4	遍历位置4

代码实现

C# 实现

public class Solution {
    public int MaxSubArrayLen(int[] nums, int k) {
        Dictionary<long, int> dict = new Dictionary<long, int>();
        dict[0] = -1; // 初始化，处理从0开始的子数组
        long sum = 0;
        int maxLen = 0;
        
        for (int i = 0; i < nums.Length; i++) {
            sum += nums[i];
            
            // 检查当前和是否等于k
            if (sum == k) {
                maxLen = i + 1;
            }
            
            // 检查是否存在sum-k的前缀和
            if (dict.ContainsKey(sum - k)) {
                maxLen = Math.Max(maxLen, i - dict[sum - k]);
            }
            
            // 只保存第一次出现的位置
            if (!dict.ContainsKey(sum)) {
                dict[sum] = i;
            }
        }
        
        return maxLen;
    }
}

Python 实现

class Solution:
    def maxSubArrayLen(self, nums: List[int], k: int) -> int:
        prefix_sum = {0: -1}  # 初始化，处理从0开始的子数组
        curr_sum = 0
        max_len = 0
        
        for i, num in enumerate(nums):
            curr_sum += num
            
            # 检查当前和是否等于k
            if curr_sum == k:
                max_len = i + 1
            
            # 检查是否存在curr_sum-k的前缀和
            if curr_sum - k in prefix_sum:
                max_len = max(max_len, i - prefix_sum[curr_sum - k])
            
            # 只保存第一次出现的位置
            if curr_sum not in prefix_sum:
                prefix_sum[curr_sum] = i
        
        return max_len

C++ 实现

class Solution {
public:
    int maxSubArrayLen(vector<int>& nums, int k) {
        unordered_map<long long, int> prefix_sum;
        prefix_sum[0] = -1; // 初始化，处理从0开始的子数组
        long long curr_sum = 0;
        int max_len = 0;
        
        for (int i = 0; i < nums.size(); i++) {
            curr_sum += nums[i];
            
            // 检查当前和是否等于k
            if (curr_sum == k) {
                max_len = i + 1;
            }
            
            // 检查是否存在curr_sum-k的前缀和
            if (prefix_sum.find(curr_sum - k) != prefix_sum.end()) {
                max_len = max(max_len, i - prefix_sum[curr_sum - k]);
            }
            
            // 只保存第一次出现的位置
            if (prefix_sum.find(curr_sum) == prefix_sum.end()) {
                prefix_sum[curr_sum] = i;
            }
        }
        
        return max_len;
    }
};