Leetcode #325:和等于 k 的最长子数组长度

题目

题干

该问题 和等于 k 的最长子数组长度，题面：

和等于k的最长子数组长度

Given an array nums and a target value k, find the maximum length of a subarray that sums to k. If there isn‘t one, return 0 instead.
Note:
The sum of the entire nums array is guaranteed to fit within the 32-bit signed integer range.

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

注意: nums 数组的总和是一定在 32 位有符号整数范围之内的。

示例

示例 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，且长度最长。

题解

暴力破解

C++

class Solution {
    public int maxSubArrayLen(int[] nums, int k) {
        int len = nums.length;
        int sum = 0;
        int max = 0;
        int[] sums = new int[len];
        //1.把到目前为止的sum储存进新建的array里，如果有和k相等的sum则与max做比较
        for(int i=0; i<len; i++){            
            sum += nums[i];
            sums[i] = sum;
            if(sum == k) max = Math.max(max, i+1);
        }
        //2.对于每一位，从前往后开始一次砍去，如果遇到于sum相等则与max做比较，直接
        //break是因为如果找到了后面不可能比前面长
        for(int i=0; i<len; i++){
            sum = sums[i];
            for(int j=0; j<i; j++){
                sum -= nums[j];
                if(sum == k) {
                    max = Math.max(max, i-j);//
                    break;
                }
            }
        }
        if(max > 0) return max;
        else return 0;
    }
};

Python

class Solution(object):
    def __init__(self, nums: list, k: int):
        self.nums = nums
        self.k = k

    def max_sub_len(self):
        max_len = 0
        sums = []
        # 把到目前为止的sum储存进新建的list里，如果有和k相等的sum则与max做比较
        sum_forward = 0
        for i in range(len(self.nums)):
            sum_forward += self.nums[i]
            sums.append(sum_forward)
            if sum_forward == self.k:
                max_len = max(max_len, i + 1)
        # 对于每一位，从前往后开始一次砍去，如果遇到与sum相等则与max做比较
        # 直接break是因为如果找到了后面不可能比前面长
        for i in range(len(self.nums)):
            sum_left = sums[i]
            for j in range(i):
                sum_left -= self.nums[j]
                if sum_left == self.k:
                    max_len = max(max_len, i-j)
                    break
        if max_len > 0:
            return max_len
        else:
            return 0

时间复杂度是O(N),主要原因是我们需要找出sum值减多少才能等于目标k，也就是sums[i] - sum[j] = k

哈希表

如果我们能用字典来储存sum的话，就可以快速找出sums[i] - k的index。
需要注意的是字典里所有的Key值是唯一的，所以需要先判定是否已经存在，如果存在则不保存，因为对应的value值越小长度越大。

C++

class Solution {
    public int maxSubArrayLen(int[] nums, int k) {
        int len = nums.length;
        Map<Integer, Integer> map = new HashMap<>();
        int sum = 0;
        int max = 0;
        for(int i=0; i<len; i++){
            sum += nums[i];
            if(sum == k) max = Math.max(max, i+1);
            if(map.containsKey(sum-k)) max = Math.max(max,i-map.get(sum-k));
            if(!map.containsKey(sum)) map.put(sum, i);
        }
        if(max > 0) return max;
        else return 0;
    }
};

Python

class Solution(object):
    def __init__(self, nums, k):
        self.nums = nums
        self.k = k

    def max_sub_len(self):
        map_sum = {}
        sum_forward = 0
        max_len = 0
        for i in range(len(self.nums)):
            sum_forward += self.nums[i]
            if sum_forward == self.k:
                max_len = max(max_len, i + 1)
            if sum_forward-self.k in map_sum:
                max_len = max(max_len, i - map_sum[sum_forward-self.k])
            if sum_forward not in map_sum:
                map_sum[sum_forward] = i
        if max_len > 0:
            return max_len
        else:
            return 0