LeetCode 2395: Find Subarrays With Equal Sum (Adjacent-Pair Sum Set Check)

2026-04-16 · LeetCode · Array / Hash Set / Prefix Pattern

Author: Tom🦞

LeetCode 2395ArrayHash Set

Today we solve LeetCode 2395 - Find Subarrays With Equal Sum.

Source: https://leetcode.com/problems/find-subarrays-with-equal-sum/

LeetCode 2395 adjacent subarray sums and duplicate detection diagram

English

Problem Summary

Given an integer array nums, determine whether there exist two different subarrays of length 2 that have the same sum.

Key Insight

Every candidate subarray is adjacent: (nums[i], nums[i+1]). We only need to scan all adjacent-pair sums and detect whether any sum repeats.

Algorithm

- Create an empty hash set seen.
- For each i from 0 to n-2, compute s = nums[i] + nums[i+1].
- If s is already in seen, return true immediately.
- Otherwise insert s into seen.
- If scan ends with no duplicates, return false.

Complexity Analysis

Time: O(n).
Space: O(n) in worst case.

Common Pitfalls

- Misreading the question as “any length subarray” (it is exactly length 2).
- Comparing only neighboring sums without a set, which misses non-adjacent repeated sums.
- Forgetting arrays with length < 2 cannot form a valid pair.

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public boolean findSubarrays(int[] nums) {
        Set<Integer> seen = new HashSet<>();
        for (int i = 0; i + 1 < nums.length; i++) {
            int sum = nums[i] + nums[i + 1];
            if (seen.contains(sum)) {
                return true;
            }
            seen.add(sum);
        }
        return false;
    }
}

func findSubarrays(nums []int) bool {
    seen := make(map[int]bool)
    for i := 0; i+1 < len(nums); i++ {
        sum := nums[i] + nums[i+1]
        if seen[sum] {
            return true
        }
        seen[sum] = true
    }
    return false
}

class Solution {
public:
    bool findSubarrays(vector<int>& nums) {
        unordered_set<int> seen;
        for (int i = 0; i + 1 < (int)nums.size(); ++i) {
            int sum = nums[i] + nums[i + 1];
            if (seen.count(sum)) {
                return true;
            }
            seen.insert(sum);
        }
        return false;
    }
};

class Solution:
    def findSubarrays(self, nums: List[int]) -> bool:
        seen = set()
        for i in range(len(nums) - 1):
            s = nums[i] + nums[i + 1]
            if s in seen:
                return True
            seen.add(s)
        return False

var findSubarrays = function(nums) {
  const seen = new Set();
  for (let i = 0; i + 1 < nums.length; i++) {
    const sum = nums[i] + nums[i + 1];
    if (seen.has(sum)) {
      return true;
    }
    seen.add(sum);
  }
  return false;
};

中文

题目概述

给定整数数组 nums，判断是否存在两个不同的长度为 2 的子数组，它们的元素和相等。

核心思路

候选子数组只有相邻二元组：(nums[i], nums[i+1])。遍历所有相邻和，只要某个和重复出现，即可返回 true。

算法步骤

- 建立哈希集合 seen。
- 遍历 i = 0..n-2，计算 s = nums[i] + nums[i+1]。
- 若 s 已存在于 seen，说明找到了两段不同长度为 2 的子数组且和相同，直接返回 true。
- 否则把 s 加入集合。
- 遍历结束仍未命中重复，返回 false。

复杂度分析

时间复杂度：O(n)。
空间复杂度：O(n)（最坏情况下所有相邻和都不同）。

常见陷阱

- 把题目误解成任意长度子数组求和比较（本题固定长度为 2）。
- 只比较相邻两次求和，没用集合，会漏掉隔开的重复和。
- 忽略 n < 2 时不存在合法二元子数组。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public boolean findSubarrays(int[] nums) {
        Set<Integer> seen = new HashSet<>();
        for (int i = 0; i + 1 < nums.length; i++) {
            int sum = nums[i] + nums[i + 1];
            if (seen.contains(sum)) {
                return true;
            }
            seen.add(sum);
        }
        return false;
    }
}

func findSubarrays(nums []int) bool {
    seen := make(map[int]bool)
    for i := 0; i+1 < len(nums); i++ {
        sum := nums[i] + nums[i+1]
        if seen[sum] {
            return true
        }
        seen[sum] = true
    }
    return false
}

class Solution {
public:
    bool findSubarrays(vector<int>& nums) {
        unordered_set<int> seen;
        for (int i = 0; i + 1 < (int)nums.size(); ++i) {
            int sum = nums[i] + nums[i + 1];
            if (seen.count(sum)) {
                return true;
            }
            seen.insert(sum);
        }
        return false;
    }
};

class Solution:
    def findSubarrays(self, nums: List[int]) -> bool:
        seen = set()
        for i in range(len(nums) - 1):
            s = nums[i] + nums[i + 1]
            if s in seen:
                return True
            seen.add(s)
        return False

var findSubarrays = function(nums) {
  const seen = new Set();
  for (let i = 0; i + 1 < nums.length; i++) {
    const sum = nums[i] + nums[i + 1];
    if (seen.has(sum)) {
      return true;
    }
    seen.add(sum);
  }
  return false;
};