What is the key pattern in Find Subarrays With Equal Sum?

The core pattern is array scanning plus hash lookup. You compute each adjacent pair sum once and use a hash set to detect whether that exact length-2 sum appeared earlier.

Why does a duplicate sum guarantee the answer is true?

Each stored sum came from a specific starting index i. If the same sum appears again at a later index j, then two different length-2 subarrays have equal sum, which satisfies the condition.

Do the two subarrays need to be non-overlapping?

No. They only need to begin at different indices. Overlap is allowed, which is why [0,0,0] returns true from windows starting at indices 0 and 1.

Can this be solved without extra space?

Yes, you could compare every length-2 window against every later window, but that takes O(n^2) time. The hash-set solution uses extra space to keep the scan linear.

Why not use prefix sums for LeetCode 2395?

Prefix sums can compute window sums, but here every window already has fixed size 2, so nums[i] + nums[i+1] is simpler and clearer. A hash set on those direct sums is the most targeted solution for this problem.

#2395

Easy

auto_awesome数组·哈希·扫描

LeetCode 题解工作台

和相等的子数组

给你一个下标从 0 开始的整数数组 nums ，判断是否存在两个长度为 2 的子数组且它们的和相等。注意，这两个子数组起始位置的下标必须不相同。如果这样的子数组存在，请返回 true ，否则返回 false 。子数组是一个数组中一段连续非空的元素组成的序列。示例 1：输入： n…

数组哈希表

题目描述

给你一个下标从 0 开始的整数数组 nums ，判断是否存在两个长度为 2 的子数组且它们的和相等。注意，这两个子数组起始位置的下标必须 不相同 。

如果这样的子数组存在，请返回 true，否则返回 false 。

子数组 是一个数组中一段连续非空的元素组成的序列。

示例 1：

输入：nums = [4,2,4]
输出：true
解释：元素为 [4,2] 和 [2,4] 的子数组有相同的和 6 。

示例 2：

输入：nums = [1,2,3,4,5]
输出：false
解释：没有长度为 2 的两个子数组和相等。

示例 3：

输入：nums = [0,0,0]
输出：true
解释：子数组 [nums[0],nums[1]] 和 [nums[1],nums[2]] 的和相等，都为 0 。
注意即使子数组的元素相同，这两个子数组也视为不相同的子数组，因为它们在原数组中的起始位置不同。

提示：

2 <= nums.length <= 1000
-10⁹ <= nums[i] <= 10⁹

lightbulb

解题思路

方法一：哈希表

我们可以遍历数组 $nums$ ，用哈希表 $vis$ 记录数组中每两个相邻元素的和，如果当前两个元素的和已经在哈希表中出现过，则返回 true，否则将当前两个元素的和加入哈希表中。

遍历结束后，说明没有找到满足条件的两个子数组，返回 false。

时间复杂度 $O(n)$ ，空间复杂度 $O(n)$ 。其中 $n$ 为数组 $nums$ 的长度。

1

2

3

4

5

6

7

8

9

class Solution:
    def findSubarrays(self, nums: List[int]) -> bool:
        vis = set()
        for a, b in pairwise(nums):
            if (x := a + b) in vis:
                return True
            vis.add(x)
        return False

speed

复杂度分析

指标	值
时间	Depends on the final approach
空间	Depends on the final approach

psychology

面试官常问的追问

外企场景

question_mark
The interviewer emphasizes subarrays of fixed length 2, which usually means scan adjacent windows instead of using nested loops.
question_mark
They mention different starting indices, which signals that equal content is allowed as long as the windows come from separate positions.
question_mark
A hint about counting or tracking subarray sums points straight to a hash set or hash map keyed by each pair sum.

warning

常见陷阱

外企场景

error
Comparing subarrays themselves instead of comparing their length-2 sums adds unnecessary work and misses the actual requirement.
error
Forgetting that overlapping windows are allowed causes wrong answers on cases like [0,0,0], where both valid windows share elements.
error
Using an O(n^2) search over all window pairs solves small inputs but ignores the intended one-pass hash lookup pattern.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Count how many distinct length-2 sums appear more than once instead of returning a boolean.
arrow_right_alt
Return the starting indices of the first two length-2 subarrays with equal sum rather than only true or false.
arrow_right_alt
Generalize from size 2 to size k, where you would maintain a sliding window sum and still track repeated totals in a hash set.

help

常见问题

外企场景

继续练习

#2399 检查相同字母间的距离 #2402 会议室 III #2404 出现最频繁的偶数元素