一个数组可以被重复分割为两个总和相等的子数组的次数

假设我们有一个正整数数组 nums，现在需要将其分为两个非空子数组，使得这两个子数组的元素总和相等。

要求返回所有可能的方案数。

方法一：暴力枚举

最暴力的方法是枚举所有的子数组，然后再逐个比较它们的和是否相等。

具体来说，假设 nums 的长度为 n，我们需要枚举所有可能的左右区间，然后计算它们的和，最后判断它们是否相等。时间复杂度为 O(n^3)。

def count_equal_sum_subarrays(nums):
    n = len(nums)
    ans = 0
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j, n):
                if sum(nums[i:j]) == sum(nums[j:k]):
                    ans += 1
    return ans

方法二：前缀和

我们可以使用前缀和来优化暴力枚举的时间复杂度。具体来说，我们可以用一个数组 prefix_sum 表示 nums 的前缀和，然后枚举左右区间，再利用前缀和计算它们的和。这样时间复杂度可以降到 O(n^2)。

def count_equal_sum_subarrays(nums):
    n = len(nums)
    prefix_sum = [0] * (n + 1)
    for i in range(1, n + 1):
        prefix_sum[i] = prefix_sum[i - 1] + nums[i - 1]
    ans = 0
    for i in range(n):
        for j in range(i + 1, n):
            if prefix_sum[j + 1] - prefix_sum[i] == prefix_sum[n] - prefix_sum[j + 1]:
                ans += 1
    return ans

方法三：动态规划

我们可以将问题转化为一个经典的动态规划问题。

具体来说，我们可以定义一个二维数组 dp，其中 dp[i][j] 表示将前 i 个数分成两个子数组，使得两个子数组的和相等，是否有可能。

状态转移方程如下：

dp[i][j] = dp[i - 1][j - nums[i - 1]] or dp[i - 1][j]

其中 nums[i - 1] 表示第 i 个数的值。

这个方程的含义是，当前元素 nums[i - 1] 可以加入到第一个子数组中，也可以不加入，从而加入到第二个子数组中。

最终的答案为 dp[n][sum(nums) // 2]，其中 n 表示 nums 的长度。

时间复杂度为 O(n * sum(nums))。

def count_equal_sum_subarrays(nums):
    n = len(nums)
    target_sum = sum(nums)
    if target_sum % 2 != 0:
        return 0
    target_sum //= 2
    dp = [[False] * (target_sum + 1) for _ in range(n + 1)]
    dp[0][0] = True
    for i in range(1, n + 1):
        dp[i][0] = True
        for j in range(1, target_sum + 1):
            if j >= nums[i - 1]:
                dp[i][j] = dp[i - 1][j - nums[i - 1]] or dp[i - 1][j]
            else:
                dp[i][j] = dp[i - 1][j]
    return int(dp[n][target_sum])

总结

本文介绍了三种解决方案，分别是暴力枚举、前缀和、动态规划。它们的时间复杂度分别为 O(n^3)，O(n^2)，O(n * sum(nums))，其中前缀和是效率最高的。

如果感兴趣，读者可以去 LeetCode 上尝试 416. Partition Equal Subset Sum 这道题，它是本文介绍的问题的扩展版本。