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

题目：

给你一个整数数组 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

分析：

当需要在数组中寻找一个范围，使得其值满足某条件时，考虑使用滑动窗口。时间复杂度：O(n)。

所以首先利用滑动窗口得到所有的可能的区间 [left, right)。

List<int[]> res = new ArrayList<>();
int i = 0, j = 0;
int sum = 0;
while (j < arr.length) {
    sum += arr[j++];
    if (sum < target) continue;
    while (sum > target) sum -= arr[i++];
    if (sum == target) {
    res.add(new int[]{i, j});
    }
}

主要的思想是：先将 j 向右扩展，每扩展一次检查一下当前的 sum 与 target 的关系。如果 sum < target, 那么还可以继续扩展 j；如果 sum > target, 那么就需要缩小窗口了，于是增加 i；当 sum == target 时，得到一个解，存到 res 中。

接下来，对 res 中的 [left, right) 进行排序，序定义为区间长度，按升序排列。时间复杂度：O(nlogn) (n = res.size())

if (res.size() < 2) return -1;

// 将 res 按照区间长度进行排序
Collections.sort(res, (o1, o2) -> (len(o1)) - (len(o2)));

下面，需要从排好序的 res 中挑选的长度和最小的两个不重叠的区间。

考虑：res.get(0) 一定要取吗？

答：不一定。如：arr = [1, 3, 3, 4, 2, 1, 1], target = 7。res = {[0, 3), [2, 4), [3, 6)}, 排序后, res = {[2, 4), [0, 3), [3, 6)}。这时，如果直接取第 0 个区间 [2, 4) 的话，后面的区间都取不了，会返回-1，而实际应当返回6。

所以，就只能使用两重循环，但是可以根据排好序的特点在循环内部进行优化。

int ans = Integer.MAX_VALUE;
for (int index = 0; index < res.size() - 1; index++) {
    int[] a1 = res.get(index);

    // 如果当前区间的长度的两倍 >= ans, 那么由于是排好序的，后面的区间不会更小，所以直接break
    if ((len(a1)) * 2 >= ans) break; 

    for (int k = index + 1; k < res.size(); k++) {
        int[] a2 = res.get(k);
        // 不重叠的情况有两种：a2在a1右边，a2在a1的左边
        if (a2[0] >= a1[1] || a2[1] <= a1[0]) { 
            ans = Math.min(ans, len(a1) + len(a2));
            
            // 由于是排好序的，后面的区间不会更小，直接 break
            break;
        }
    }
}

return ans == Integer.MAX_VALUE ? -1 : ans;

整体代码

class Solution {
    public int minSumOfLengths(int[] arr, int target) {
        // 滑动窗口：先求出所有满足 target 的下标对
        List<int[]> res = new ArrayList<>();

        int i = 0, j = 0;
        int sum = 0;
        while (j < arr.length) {
            sum += arr[j++];
            if (sum < target) continue;
            while (sum > target) sum -= arr[i++];
            if (sum == target) {
                res.add(new int[]{i, j});
            }
        }
        if (res.size() < 2) return -1;
        
        // 将 res 按照区间长度进行排序
        Collections.sort(res, (o1, o2) -> (len(o1)) - (len(o2)));
        
        int ans = Integer.MAX_VALUE;
        for (int index = 0; index < res.size() - 1; index++) {
            int[] a1 = res.get(index);
            if ((len(a1)) * 2 >= ans) break; 
            for (int k = index + 1; k < res.size(); k++) {
                int[] a2 = res.get(k);
                if (a2[0] >= a1[1] || a2[1] <= a1[0]) {
                    ans = Math.min(ans, len(a1) + len(a2));
                    break;
                }
            }
        }

        return ans == Integer.MAX_VALUE ? -1 : ans;
    }
    // 表示半开半闭区间 [a[0], a[1]) 的长度
    private int len(int[] a) {
        return a[1] - a[0];
    }
}