<p>You are given an array of integers <code>arr</code> and an integer <code>target</code>.</p>

<p>You have to find <strong>two non-overlapping sub-arrays</strong> of <code>arr</code> each with a sum equal <code>target</code>. There can be multiple answers so you have to find an answer where the sum of the lengths of the two sub-arrays is <strong>minimum</strong>.</p>

<p>Return <em>the minimum sum of the lengths</em> of the two required sub-arrays, or return <code>-1</code> if you cannot find such two sub-arrays.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> arr = [3,2,2,4,3], target = 3
<strong>Output:</strong> 2
<strong>Explanation:</strong> Only two sub-arrays have sum = 3 ([3] and [3]). The sum of their lengths is 2.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> arr = [7,3,4,7], target = 7
<strong>Output:</strong> 2
<strong>Explanation:</strong> 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.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> arr = [4,3,2,6,2,3,4], target = 6
<strong>Output:</strong> -1
<strong>Explanation:</strong> We have only one sub-array of sum = 6.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= arr.length &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
	<li><code>1 &lt;= target &lt;= 10<sup>8</sup></code></li>
</ul>

from typing import List
from collections import defaultdict

class Solution:
    def minSumOfLengths(self, arr: List[int], target: int) -> int:
        n = len(arr)
        
        # Helper function to compute minimum lengths of subarrays with target sum
        def compute_min_lengths(arr: List[int]) -> List[int]:
            min_length = [float('inf')] * n
            current_sum = 0
            prefix_sums = {0: -1}
            
            for i in range(n):
                current_sum += arr[i]
                if current_sum - target in prefix_sums:
                    start_index = prefix_sums[current_sum - target]
                    min_length[i] = i - start_index
                prefix_sums[current_sum] = i
                
                if i > 0:
                    min_length[i] = min(min_length[i], min_length[i - 1])
            
            return min_length
        
        min_len_left = compute_min_lengths(arr)
        reversed_arr = arr[::-1]
        min_len_right = compute_min_lengths(reversed_arr)[::-1]
        
        min_sum = float('inf')
        
        for i in range(n - 1):
            if min_len_left[i] < float('inf') and min_len_right[i + 1] < float('inf'):
                min_sum = min(min_sum, min_len_left[i] + min_len_right[i + 1])
        
        return min_sum if min_sum < float('inf') else -1

42400