Formatted question description: https://leetcode.ca/all/1477.html

# 1477. Find Two Non-overlapping Sub-arrays Each With Target Sum

## Level

Medium

## Description

Given an array of integers `arr`

and an integer `target`

.

You have to find **two non-overlapping sub-arrays** of `arr`

each with sum equal `target`

. There can be multiple answers so you have to find an answer where the sum of the lengths of the two sub-arrays is **minimum**.

Return *the minimum sum of the lengths* of the two required sub-arrays, or return ** -1** if you cannot find such two sub-arrays.

**Example 1:**

**Input:** arr = [3,2,2,4,3], target = 3

**Output:** 2

**Explanation:** Only two sub-arrays have sum = 3 ([3] and [3]). The sum of their lengths is 2.

**Example 2:**

**Input:** arr = [7,3,4,7], target = 7

**Output:** 2

**Explanation:** Although we have three non-overlapping sub-arrays of sum = 7 ([7], [3,4] and [7]), but we will choose the first and third sub-arrays as the sum of their lengths is 2.

**Example 3:**

**Input:** arr = [4,3,2,6,2,3,4], target = 6

**Output:** -1

**Explanation:** We have only one sub-array of sum = 6.

**Example 4:**

**Input:** arr = [5,5,4,4,5], target = 3

**Output:** -1

**Explanation:** We cannot find a sub-array of sum = 3.

**Example 5:**

**Input:** arr = [3,1,1,1,5,1,2,1], target = 3

**Output:** 3

**Explanation:** Note that sub-arrays [1,2] and [2,1] cannot be an answer because they overlap.

**Constraints:**

`1 <= arr.length <= 10^5`

`1 <= arr[i] <= 1000`

`1 <= target <= 10^8`

## Solution

First, use the idea of sliding window to obtain all subarrays that have sum equal to `target`

, and use a list to store each subarray’s start index and end index. Sort the subarrays according to their lengths in ascending order. Then find the two shortest arrays that do not overlap, and return the sum of their lengths.

Java

```
class Solution {
public int minSumOfLengths(int[] arr, int target) {
List<int[]> indices = new ArrayList<int[]>();
int length = arr.length;
int sum = 0;
int start = 0, end = 0;
while (end < length) {
sum += arr[end];
while (sum > target) {
sum -= arr[start];
start++;
}
if (sum == target) {
indices.add(new int[]{start, end});
sum -= arr[start];
start++;
}
end++;
}
int size = indices.size();
if (size <= 1)
return -1;
Collections.sort(indices, new Comparator<int[]>() {
public int compare(int[] array1, int[] array2) {
if (array1[1] - array1[0] != array2[1] - array2[0])
return (array1[1] - array1[0]) - (array2[1] - array2[0]);
else
return array1[0] - array2[0];
}
});
int[] array0 = indices.get(0);
int length1 = array0[1] - array0[0] + 1;
int length2 = Integer.MAX_VALUE;
for (int i = 1; i < size; i++) {
int[] array = indices.get(i);
int curLength = array[1] - array[0] + 1;
if (array[0] > array0[1] || array[1] < array0[0]) {
length2 = curLength;
return length1 + length2;
}
if (curLength > length1) {
for (int j = 0; j < i; j++) {
int[] prevArray = indices.get(j);
int prevLength = prevArray[1] - prevArray[0] + 1;
if (prevLength == length1 && (array[0] > prevArray[1] || array[1] < prevArray[0])) {
length2 = curLength;
return length1 + length2;
}
}
}
}
return -1;
}
}
```