2026-05-17：中心子数组的数量。用go语言，给定一个整数数组 nums。 考虑数组中的任意一个连续非空子数组。若该子数组的“总和”恰好等于

2026-05-17：中心子数组的数量。用go语言，给定一个整数数组 nums。

考虑数组中的任意一个连续非空子数组。若该子数组的“总和”恰好等于该子数组中“至少一个元素的值”，则称这个子数组为中心子数组。

你的任务是：统计 nums 中所有中心子数组的数量，并返回这个数量。

1 <= nums.length <= 500。

-100000 <= nums[i] <= 100000。

输入: nums = [-1,1,0]。

输出: 5。

解释:

所有单元素子数组（[-1]，[1]，[0]）都是中心子数组。

子数组 [1, 0] 的元素之和为 1，且 1 存在于该子数组中。

子数组 [-1, 1, 0] 的元素之和为 0，且 0 存在于该子数组中。

因此，答案是 5。

题目来自力扣3804。

中心子数组统计过程详细解析 第一步：明确所有连续非空子数组

数组长度为3，总共有6个连续非空子数组（所有可能的连续片段）：

1. 1.[-1]（起始索引0，结束索引0）

2. 2.[-1,1]（起始索引0，结束索引1）

3. 3.[-1,1,0]（起始索引0，结束索引2）

4. 4.[1]（起始索引1，结束索引1）

5. 5.[1,0]（起始索引1，结束索引2）

6. 6.[0]（起始索引2，结束索引2）

代码的核心逻辑是：固定子数组的起点，依次扩展终点，遍历所有子数组，同时用哈希表记录当前子数组包含的元素，快速判断「总和是否存在于子数组中」。

阶段1：固定起点为索引0（元素：-1）

从第一个元素开始，逐步向右扩展子数组：

1. 1.子数组 [-1]

• • 元素：{-1}

• • 总和：-1

• • 判断：总和 -1 存在于元素中 → 是中心子数组，计数+1

2.子数组 [-1,1]

• • 元素：{-1,1}

• • 总和：-1+1=0

• • 判断：总和0 不存在于元素中 → 不是，计数不变

3.子数组 [-1,1,0]

• • 元素：{-1,1,0}

• • 总和：-1+1+0=0

• • 判断：总和0 存在于元素中 → 是中心子数组，计数+1
  ✅ 此阶段累计：2个

清空之前的记录，从第二个元素开始扩展：

1. 1.子数组 [1]

• • 元素：{1}

• • 总和：1

• • 判断：总和1 存在于元素中 → 是中心子数组，计数+1

2.子数组 [1,0]

• • 元素：{1,0}

• • 总和：1+0=1

• • 判断：总和1 存在于元素中 → 是中心子数组，计数+1
  ✅ 此阶段累计：2个（总计数：4）

清空之前的记录，从第三个元素开始扩展：

1. 1.子数组 [0]

• • 元素：{0}

• • 总和：0

• • 判断：总和0 存在于元素中 → 是中心子数组，计数+1
  ✅ 此阶段累计：1个（总计数：5）

所有符合条件的中心子数组：

1. 1. [-1]

2. 2. [-1,1,0]

3. 3. [1]

4. 4. [1,0]

5. 5. [0]
   总计5个，与题目输出一致。

1. 1.双重循环遍历所有子数组：外层循环固定子数组的起点，内层循环从起点开始向右扩展，确定子数组的终点，覆盖所有连续子数组。

2. 2.哈希表记录当前子数组元素：每扩展一个终点，就把新元素存入哈希表（快速去重，只记录元素是否存在）。

3. 3.实时计算子数组总和：每扩展一个元素，就累加计算当前子数组的总和。

4. 4.快速判断：检查「总和」是否在哈希表中（即是否存在于当前子数组），如果存在，就将结果计数+1。

• • 外层循环：遍历数组的每个元素作为起点，执行n 次（n是数组长度）。

• • 内层循环：每个起点最多向右遍历到数组末尾，平均执行n/2 次，总次数为 n² 级别。

• • 哈希表的插入、查询操作都是O(1)常数时间。

• • 总时间复杂度：O(n²)（n为数组长度，本题n≤500，n²=25万，完全满足要求）。

• • 代码中使用了一个哈希表，每次遍历新起点时都会清空哈希表。

• • 哈希表最多存储当前子数组的所有唯一元素，子数组最长为n，元素最多n个。

• • 总空间复杂度：O(n)（额外空间仅为哈希表，最大占用n个元素的空间）。

1. 1. 计算过程：通过固定起点+扩展终点遍历所有连续子数组，用哈希表记录元素，实时计算总和并判断是否符合条件；

2. 2. 时间复杂度：O(n²)（双重循环）；

3. 3. 空间复杂度：O(n)（哈希表临时存储元素）。

package main

 import (
    "fmt"
)

 func centeredSubarrays(nums []int) (ans int) {
    has := map[int]int{}
    for i := range nums {
        clear(has)
        s := 0
        for _, x := range nums[i:] {
            has[x] = 1
            s += x
            ans += has[s]
        }
    }
    return
}

 func main() {
    nums := []int{-1, 1, 0}
    result := centeredSubarrays(nums)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 def centeredSubarrays(nums):
    ans = 0
    n = len(nums)
    for i in range(n):
        has = {}
        s = 0
        for j in range(i, n):
            x = nums[j]
            has[x] = 1
            s += x
            ans += has.get(s, 0)
    return ans

 def main():
    nums = [-1, 1, 0]
    result = centeredSubarrays(nums)
    print(result)

 if __name__ == "__main__":
    main()

C++完整代码如下：

  

  

  


 using namespace std;

 int centeredSubarrays(vector& nums) {
    int ans = 0;
    unordered_map has;

     for (int i = 0; i < nums.size(); i++) {
        has.clear();
        int s = 0;
        for (int j = i; j < nums.size(); j++) {
            int x = nums[j];
            has[x] = 1;
            s += x;
            ans += has[s];  // 如果 s 不存在于 map 中，has[s] 会返回 0
        }
    }
    return ans;
}

 int main() {
    vector nums = {-1, 1, 0};
    int result = centeredSubarrays(nums);
    cout << result << endl;
    return0;
}

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。 欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。