一个数组可以重复划分为两个等和的子数组的次数

在给定的整数数组中，如果有一种方式可以将该数组分成两个子数组，使得两个子数组的和相同，则称该数组具有重复划分的性质。本文将探讨如何计算数组具有这种性质的次数。

方法一：暴力枚举

我们可以用两个循环来枚举所有可能的划分方式，然后判断两个子数组的和是否相等。时间复杂度为 $O(n^3)$。

public int countPartitions(int[] nums) {
    int n = nums.length, count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int sum1 = 0;
            for (int k = i; k <= j; k++) {
                sum1 += nums[k];
            }
            for (int m = j + 1; m < n; m++) {
                int sum2 = 0;
                for (int k = j + 1; k <= m; k++) {
                    sum2 += nums[k];
                }
                if (sum1 == sum2) {
                    count++;
                }
            }
        }
    }
    return count;
}

方法二：前缀和+哈希表

我们可以先计算出数组的前缀和数组 $preSum$，然后枚举两个子数组的划分点，将整个数组分为三段，并且要求三段的和都相等。由于要求划分点不能在数组的首尾，因此枚举的范围为 $[1, n-2]$。对于每个划分点，我们可以用哈希表来记录前面的前缀和出现的次数，以便于快速查找。

时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。

public int countPartitions(int[] nums) {
    int n = nums.length, count = 0;
    int[] preSum = new int[n + 1];
    for (int i = 1; i <= n; i++) {
        preSum[i] = preSum[i - 1] + nums[i - 1];
    }
    for (int i = 2; i < n; i++) {
        int sum1 = preSum[i];
        Map<Integer, Integer> map = new HashMap<>();
        for (int j = 1; j < i; j++) {
            int sum2 = preSum[j];
            int sum3 = preSum[n] - preSum[i];
            if (sum1 == sum2 && sum2 == sum3) {
                count++;
            }
            map.put(sum2, map.getOrDefault(sum2, 0) + 1);
        }
        for (int j = i + 1; j < n; j++) {
            int sum2 = preSum[j] - preSum[i];
            int sum3 = preSum[n] - preSum[j];
            if (sum1 == sum2 && sum2 == sum3) {
                count++;
            }
            if (map.containsKey(sum1 - sum2)) {
                count += map.get(sum1 - sum2);
            }
        }
    }
    return count;
}

方法三：前缀和+双指针

我们可以先计算出数组的前缀和数组 $preSum$，然后枚举两个子数组的划分点，将整个数组分为三段，并且要求三段的和都相等。由于要求划分点不能在数组的首尾，因此枚举的范围为 $[1, n-2]$。对于每个划分点，我们可以用双指针来查找第二个子数组的结束位置。

时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。

public int countPartitions(int[] nums) {
    int n = nums.length, count = 0;
    int[] preSum = new int[n + 1];
    for (int i = 1; i <= n; i++) {
        preSum[i] = preSum[i - 1] + nums[i - 1];
    }
    for (int i = 2; i < n; i++) {
        int sum1 = preSum[i];
        int left = 1, right = n - 2;
        while (left < i && right > i) {
            int sum2 = preSum[left];
            int sum3 = preSum[n] - preSum[right + 1];
            if (sum1 == sum2 && sum2 == sum3) {
                count++;
                left++;
                right--;
            } else if (sum2 < sum1 || sum3 < sum1) {
                left++;
            } else {
                right--;
            }
        }
    }
    return count;
}

总结

本文介绍了三种计算具有重复划分性质的整数数组的次数的方法，分别是暴力枚举、前缀和+哈希表、前缀和+双指针。其中，前缀和+哈希表和前缀和+双指针的时间复杂度均为 $O(n^2)$，比暴力枚举的时间复杂度 $O(n^3)$ 要优秀很多。在实际应用中，建议使用前缀和+哈希表方法，因为哈希表可以更快地查找前缀和出现的次数，实现起来也比较简单。