LeetCode 548. 将数组分割成和相等的子数组

548. 将数组分割成和相等的子数组

给定一个有 n 个整数的数组 nums ，如果能找到满足以下条件的三元组  (i, j, k)  则返回 true ：

1. 0 < i, i + 1 < j, j + 1 < k < n - 1
2. 子数组 (0, i - 1) ， (i + 1, j - 1) ， (j + 1, k - 1) ， (k + 1, n - 1) 的和应该相等。

这里我们定义子数组 (l, r) 表示原数组从索引为 l 的元素开始至索引为 r 的元素。

示例 1: 

输入: nums = [1,2,1,2,1,2,1]
输出: True
解释:
i = 1, j = 3, k = 5. 
sum(0, i - 1) = sum(0, 0) = 1
sum(i + 1, j - 1) = sum(2, 2) = 1
sum(j + 1, k - 1) = sum(4, 4) = 1
sum(k + 1, n - 1) = sum(6, 6) = 1

示例 2:

输入: nums = [1,2,1,2,1,2,1,2]
输出: false

提示:

• n == nums.length
• 1 <= n <= 2000
• -10^6 <= nums[i] <= 10^6

解法1：前缀和 + 哈希集

首先我们建立一个累计求和数组 presum，其中 presum[i] = sum(nums[0...i]) 
数组 nums[0...i] 索引的累计求和。

然后，我们开始遍历 j 形成的切点的可能位置。 对于每一个 j，首先，我们找到所有导致第一部分总和 sum( nums[0..i - 1] ) 和第二部分总和 sum( nums[i + 1...j-1] ) 相等的 i 切点的位置 （即 presum[i−1] = presum[j−1] − presum[i] ）并将此类和存储在 set 中（对于每个所选的 j 形成一个新的哈希集）。

因此，set 中有和的存在 ：意味着对于当前位置的 j 切点，存在 i 切点 使得 第一部分总和 和 第二部分总和 相等。
然后，我们遍历 k切点 并找到导致第三部分总和 和 第四部分总和相等（presum[n−1] − presum[k] = presum[k−1] − presum[j]）的 k 切点位置，对于之前选中的 j 切点。我们同时看看相同的和是否存在于 set 中。如果有，那么就存在这样一个三元组 （i，j，k），它满足要求的标准，否则不。
查看下面的动画以对此过程有一个视觉的表示：

Java版：

class Solution {
    public boolean splitArray(int[] nums) {
        int n = nums.length;
        int[] presum = new int[n];
        presum[0] = nums[0];
        for (int i = 1; i < n; i++) {
            presum[i] = presum[i - 1] + nums[i];
        }

        // 0 < i < i + 1 < j < j + 1 < k < k + 1 < n
        for (int j = 3; j <= n - 4; j++) {
            Set<Integer> set = new HashSet<>();
            for (int i = 1; i < j - 1; i++) {
                if (presum[i - 1] == presum[j - 1] - presum[i]) {
                    set.add(presum[i - 1]);
                }
            }
            if (set.size() == 0) {
                continue;
            }
            for (int k = j + 2; k < n - 1; k++) {
                if (presum[k - 1] - presum[j] == presum[n - 1] - presum[k]) {
                    if (set.contains(presum[n - 1] - presum[k])) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

Python3版：

class Solution:
    def splitArray(self, nums: List[int]) -> bool:
        n = len(nums)
        presum = [0] * n
        presum[0] = nums[0] 
        for i in range(n):
            presum[i] = presum[i - 1] + nums[i]

        # 0 < i < i + 1 < j < j + 1 < k < k + 1 < n
        for j in range(3, n - 3):
            record = set()
            for i in range(1, j - 1):
                if presum[i - 1] == presum[j - 1] - presum[i]:
                    record.add(presum[i - 1]) 
            if len(record) == 0:
                continue
            for k in range(j + 2, n - 1):
                if presum[n - 1] - presum[k] == presum[k - 1] - presum[j]:
                    if presum[n - 1] - presum[k] in record:
                        return True
        
        return False

复杂度分析

• 时间复杂度：O(n^2)。有一个外循环和两个内循环。
• 空间复杂度：O(n)。哈希集的大小可以达到 n。