当前位置：首页 > news >正文

力扣【2348. 全0子数组的数目】——从暴力到最优的思考过程

news 2025/8/21 7:29:37

前端算法实战：用JS解决力扣【2348. 全0子数组的数目】——从暴力到最优的思考过程

引言

今天我们来聊一道在前端面试中可能让你眼前一亮的力扣题目——2348. 全0子数组的数目。这道题看似简单，实则蕴含着动态规划和数学归纳的巧妙结合，掌握它不仅能帮你应对面试，更能让你对数组问题有更深层次的理解。今天，我将带大家从前端视角出发，一步步拆解这道题，从最直观的暴力解法，到最终的数学优化，让你彻底掌握这类问题的解题精髓。

题目分析

原题链接：力扣 2348. 全0子数组的数目

在这里插入图片描述

题目大意：

给定一个整数数组 nums，我们需要找出其中所有由连续的 0 组成的子数组的数目。子数组必须是非空的。
输入输出：
- 输入：一个整数数组 nums。
- 输出：一个整数，表示全部为 0 的子数组的数目。
约束条件：
- 1 <= nums.length <= 10^5
- -10^9 <= nums[i] <= 10^9
示例演示：

示例 1: 输入: nums = [1,3,0,0,2,0,0,4] 输出: 6 解释:
- 子数组 [0] 出现了 4 次。
- 子数组 [0,0] 出现了 2 次。
- 不存在长度大于 2 的全 0 子数组，所以我们返回 6。
示例 2: 输入: nums = [0,0,0,2,0,0] 输出: 9 解释:
- 子数组 [0] 出现了 5 次。
- 子数组 [0,0] 出现了 3 次。
- 子数组 [0,0,0] 出现了 1 次。
- 不存在长度大于 3 的全 0 子数组，所以我们返回 9。
示例 3: 输入: nums = [2,10,2019] 输出: 0 解释: 没有全 0 子数组，所以我们返回 0。

分步计算示例2： 对于 nums = [0,0,0,2,0,0]：
- 连续的 0 序列有两段：[0,0,0] 和 [0,0]。
- 对于 [0,0,0] 这段：
  - 长度为 1 的 [0] 子数组有 3 个。
  - 长度为 2 的 [0,0] 子数组有 2 个。
  - 长度为 3 的 [0,0,0] 子数组有 1 个。
  - 这一段总共有 3 + 2 + 1 = 6 个全 0 子数组。
- 对于 [0,0] 这段：
  - 长度为 1 的 [0] 子数组有 2 个。
  - 长度为 2 的 [0,0] 子数组有 1 个。
  - 这一段总共有 2 + 1 = 3 个全 0 子数组。
- 总计：6 + 3 = 9 个全 0 子数组。

思路推导

这道题的核心在于如何高效地统计连续的 0 序列所能形成的全 0 子数组的数目。我们来一步步推导。

笨方法尝试：暴力枚举（不可行）

最直观的想法是暴力枚举所有的子数组，然后判断每个子数组是否全部由 0 组成。如果一个数组的长度为 n，那么它的子数组数量大约是 n^2 个。对于每个子数组，我们还需要遍历一遍来判断是否全为 0，这又是一个 O(n) 的操作。因此，总的时间复杂度将达到 O(n^3)。考虑到题目中 n 的最大值是 10^5，10^5 的三次方是 10^15，这在力扣上是绝对会超时的。所以，暴力枚举是不可行的。

优化方向：减少重复计算

既然暴力枚举不行，我们就需要寻找更高效的方法。仔细观察题目，我们发现全 0 子数组的形成，只与连续的 0 有关。当遇到非 0 元素时，连续的 0 序列就会中断。这提示我们可以将问题分解为处理一段段连续的 0。

最优思路选择：数学归纳法

假设我们发现了一段连续的 k 个 0。这段 0 可以形成多少个全 0 子数组呢？

长度为 1 的全 0 子数组有 k 个（每个 0 自身）。
长度为 2 的全 0 子数组有 k-1 个（例如 [0,0]）。
长度为 3 的全 0 子数组有 k-2 个（例如 [0,0,0]）。
…
长度为 k 的全 0 子数组有 1 个（整个 k 个 0 组成的子数组）。

将这些数目加起来，就是一个等差数列的和：1 + 2 + ... + k = k * (k + 1) / 2。

所以，我们的思路就清晰了：

遍历数组 nums。
维护一个计数器 count，记录当前连续 0 的个数。
当遇到 0 时，count 加 1。
当遇到非 0 元素时，或者遍历到数组末尾时，说明一段连续的 0 结束了。此时，我们将 count * (count + 1) / 2 加到总结果中，并将 count 重置为 0。

思路具象化：小例子辅助推演

我们以 nums = [0,0,0,2,0,0] 为例进行推演：

初始化 total_subarrays = 0，count = 0。
遍历 nums[0] = 0：count 变为 1。
遍历 nums[1] = 0：count 变为 2。
遍历 nums[2] = 0：count 变为 3。
遍历 nums[3] = 2（非 0）：
- 连续 0 序列结束，count = 3。
- total_subarrays += 3 * (3 + 1) / 2 = 3 * 4 / 2 = 6。
- count 重置为 0。
遍历 nums[4] = 0：count 变为 1。
遍历 nums[5] = 0：count 变为 2。
遍历结束（数组末尾）：
- 连续 0 序列结束，count = 2。
- total_subarrays += 2 * (2 + 1) / 2 = 2 * 3 / 2 = 3。
- count 重置为 0。
最终 total_subarrays = 6 + 3 = 9。

这与示例 2 的结果完全一致。这种方法只需要一次遍历，时间复杂度为 O(n)，空间复杂度为 O(1)，非常高效。

代码实现

根据上述思路，我们可以用 JavaScript 实现如下代码。为了符合前端最佳实践，我们使用 let/const 和箭头函数，并附上逐行注释。

/*** @param {number[]} nums* @return {number}*/
var zeroFilledSubarray = function(nums) {let totalSubarrays = 0; // 用于存储最终的全0子数组总数let currentZeroCount = 0; // 用于记录当前连续0的个数
// 遍历整个数组for (let i = 0; i < nums.length; i++) {if (nums[i] === 0) {// 如果当前元素是0，连续0的计数器加1currentZeroCount++;} else {// 如果当前元素不是0，说明连续0的序列中断了// 根据数学归纳法，将当前连续0的个数所能形成的全0子数组数量累加到总数中// 公式：k * (k + 1) / 2totalSubarrays += (currentZeroCount * (currentZeroCount + 1)) / 2;// 重置连续0的计数器currentZeroCount = 0;}}
// 循环结束后，如果数组是以0结尾，或者整个数组都是0，需要将最后一段连续0的子数组数量累加totalSubarrays += (currentZeroCount * (currentZeroCount + 1)) / 2;
return totalSubarrays;
};

代码说明：

初始化：totalSubarrays 用于累加所有全 0 子数组的数量，currentZeroCount 用于统计当前连续 0 的个数，两者都初始化为 0。
遍历逻辑：我们遍历 nums 数组的每一个元素。
- 如果 nums[i] 是 0，说明连续 0 的序列还在继续，currentZeroCount 简单地加 1。
- 如果 nums[i] 不是 0，这意味着当前的连续 0 序列已经结束了。此时，我们利用前面推导出的公式 k * (k + 1) / 2（其中 k 就是 currentZeroCount）计算出这段连续 0 所能形成的全 0 子数组数量，并将其累加到 totalSubarrays 中。然后，将 currentZeroCount 重置为 0，为下一段连续 0 的统计做准备。
边界处理：循环结束后，需要特别注意。如果数组的最后一个元素是 0，或者整个数组都是 0，那么在循环结束时，currentZeroCount 可能不为 0。这意味着还有一段连续的 0 序列没有被计算。因此，在循环结束后，我们还需要再执行一次累加操作，确保所有连续 0 序列都被正确计算。

优化提升

原代码分析：

时间复杂度：我们只对数组进行了一次遍历，每次操作都是常数时间。因此，时间复杂度为 O(n)，其中 n 是数组 nums 的长度。这对于 n 达到 10^5 的情况来说，是非常高效的。
空间复杂度：我们只使用了 totalSubarrays 和 currentZeroCount 两个变量来存储中间结果，没有使用额外的数组或复杂的数据结构。因此，空间复杂度为 O(1)。这也是最优的空间复杂度。

优化点：

这道题的解法已经非常高效，在时间和空间上都达到了最优。如果题目要求「返回全 0 子数组的具体内容」（而不是数量），那么我们需要在遍历过程中记录每个连续 0 序列的起始和结束索引，并根据公式生成对应的子数组。但这会增加空间复杂度，因为需要存储这些子数组。

拓展：

这类问题可以有很多变种，例如：

如果要求「全 X 子数组的数目」怎么办？ 思路是完全一样的，只需要将判断条件 nums[i] === 0 改为 nums[i] === X 即可。
如果要求「全 0 子数组的最大长度」怎么办？ 只需要在遍历过程中，维护一个最大连续 0 的长度即可。
如果数组是二维的（比如「最大全 0 子矩阵」） ：这类问题通常会复杂很多，可能需要将二维问题转化为一维问题来解决，或者使用更复杂的动态规划。

面试总结

考点提炼：

这道题的核心考点在于对连续子数组问题的理解和数学归纳法的应用。面试官可能希望看到你：

问题分解能力：能否将复杂问题分解为处理独立的连续 0 序列。
数学思维：能否发现连续 k 个 0 形成 k * (k + 1) / 2 个全 0 子数组的规律。
代码实现能力：能否将思路清晰地转化为高效、简洁的 JavaScript 代码。
边界条件处理：能否考虑到数组末尾的连续 0 序列的计算。

技巧总结：

遇到涉及连续子数组的问题，尤其是需要统计或计算其属性时，可以优先考虑滑动窗口、动态规划或数学归纳法。本题通过数学归纳法将问题简化为对连续 0 序列的计数，避免了复杂的动态规划状态转移。
在面试中，如果能清晰地阐述从暴力解法到最优解法的思考过程，并用小例子进行推演，会给面试官留下深刻印象。

类似题目：