leetcode1477. 找两个和为目标值且不重叠的子数组(第28双周赛第三题)

leetcode1477. 找两个和为目标值且不重叠的子数组

给你一个整数数组 arr 和一个整数值 target 。

请你在 arr 中找 两个互不重叠的子数组 且它们的和都等于 target 。可能会有多种方案，请你返回满足要求的两个子数组长度和的 最小值 。

请返回满足要求的最小长度和，如果无法找到这样的两个子数组，请返回 -1。

示例 1：

输入：arr = [3,2,2,4,3], target = 3
输出：2
解释：只有两个子数组和为 3 （[3] 和 [3]）。它们的长度和为 2 。

示例 2：

输入：arr = [7,3,4,7], target = 7
输出：2
解释：尽管我们有 3 个互不重叠的子数组和为 7 （[7], [3,4] 和 [7]），但我们会选择第一个和第三个子数组，因为它们的长度和 2 是最小值。

示例 3：

输入：arr = [4,3,2,6,2,3,4], target = 6
输出：-1
解释：我们只有一个和为 6 的子数组。

示例 4：

输入：arr = [5,5,4,4,5], target = 3
输出：-1
解释：我们无法找到和为 3 的子数组。

示例 5：

输入：arr = [3,1,1,1,5,1,2,1], target = 3
输出：3
解释：注意子数组 [1,2] 和 [2,1] 不能成为一个方案因为它们重叠了。

提示：

• 1 <= arr.length <= 10^5
• 1 <= arr[i] <= 1000
• 1 <= target <= 10^8

---

方法：哈希表+动态规划

思路：

看到这种找到子数组和为xx的题目，我们肯定要想到前缀和，如果两个位置的前缀和相减等于target，那么这两个位置之间构成的子数组即为符合条件的子数组。我们看到数组长度的数据范围很大，因此所有复杂度为O(N^2)以上的算法都过不了。

一种想法是，首先通过滑窗，找到所有和为target的子数组，记下左右下标，然后按照数组长度排序，再考虑不重叠的情况，需要考虑的边界条件很多，我们使用动态规划的方法，通过一次遍历，来找到答案。

我们需要一个变量来记录前缀和，presum，因为数组中元素都为整数，前缀和严格递增，所以维护一个哈希表pre，键为前缀和，值为这个前缀和对应的下标i，并且pre[0]=-1，这是为了考虑到从头开始的子数组。这样在遍历到i时，**如果presum-target存在与pre中，那么就存在一个符合条件的子数组，且长度为cur_len=i-pre[presum-target]。**对于查找一个元素是不是在哈希表中，时间复杂度为O(1)，对于数组中，最大为O(N)，所以我们使用哈希表来保存前缀和的位置。

我们维护dp数组，dp[i]表示arr的0-i这i+1个元素中，满足子数组和为target的最小子数组的长度，如果没有，则dp[i]=float(‘inf’)。

我们考虑状态转移方程，遍历到i的时候，两种情况：

• 如果presum-target不存在于pre中，那么dp[i] = dp[i-1]
• 如果存在，那么dp[i] = min(cur_len，dp[i-1])。

那么对于答案呢，我们首先设答案ans=n+1。（因为这个答案取不到，答案最大为n，如果最后ans还为n+1,那么返回-1）。

我们在遍历过程中，什么时候才需要更新答案呢，在我们找到了一个以该位置结尾的新子数组，且之前还找到过至少一个与它不重叠的数组。

				if pre[presum - target] >= 0 and dp[pre[presum - target]] != float('inf'):
                    ans = min(ans,cur_len+dp[pre[presum - target]])

pre[presum - target] >= 0来排除找到的是pre[0]=-1，也就是从头开始满足target的情况，那肯定是第一个找到的满足条件子数组。因为还需要满足不重叠，dp[pre[presum - target]]表示前pre[presum - target]中最短的符合条件的子数组长度，这时找到的子数组cur_len=i-pre[presum-target]，正好是从pre[presum-target]+1开始的，不重叠，更新ans。

代码：

class Solution:
    def minSumOfLengths(self, arr: List[int], target: int) -> int:
        n = len(arr)
        pre = dict() #保存前缀和为i时的下标
        pre[0] = -1
        presum = 0
        ans = n+1 #答案最大为n
        dp = [float('inf') for _ in range(n)]
        #i=0时，i-1=-1，此时dp[i-1]=dp[-1]=inf，不影响，不需单独考虑边界条件
        for i in range(n):
            presum += arr[i]
            pre[presum] = i
            dp[i] = dp[i-1]
            if presum - target in pre:
                #此时遍历到的这个数组长度
                cur_len = i - pre[presum - target]
                #更新dp
                dp[i] = min(cur_len,dp[i-1])
                #如果之前已经找到了一个满足的数组，那么看看新的答案是否比之前的小
                if pre[presum - target] >= 0 and dp[pre[presum - target]] != float('inf'):
                    ans = min(ans,cur_len+dp[pre[presum - target]])
        #ans=n+1说明只有一个符合的子数组，或者一个没有，返回-1
        return ans if ans != n+1 else -1

结果：