Find Two Non-overlapping Sub-arrays Each With Target Sum

Find Two Non-overlapping Sub-arrays Each With Target Sum - Problem

You're given an array of integers arr and a target integer target. Your mission is to find two non-overlapping subarrays where each subarray has a sum exactly equal to target.

Here's the twist: there might be multiple valid combinations, but you need to find the one where the total length of both subarrays combined is minimum.

Goal: Return the minimum sum of lengths of two required subarrays, or -1 if no such pair exists.

Example: If arr = [3,2,2,4,3] and target = 3, you could choose subarrays [3] (length 1) and [3] (length 1) for a total length of 2.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can choose subarrays [3] (at index 0) and [3] (at index 4). Both have length 1, so total length is 2.

example_2.py — Multiple Valid Pairs

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

› Output: 2

💡 Note: We can choose subarrays [7] (at index 0) and [7] (at index 3). Both have length 1, so total length is 2.

example_3.py — No Valid Solution

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

› Output: -1

💡 Note: We can find [6] and [2,3] and [3] but we need exactly two non-overlapping subarrays. The only subarray with sum 6 is [6] itself, so we cannot find two non-overlapping subarrays.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 1000
1 ≤ target ≤ 10⁸
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Scan with Smart Window

Use a sliding window to efficiently find gold deposits (subarrays with target sum)

Track Best Sites

Maintain a record of the shortest mining site found before each position

Real-time Optimization

When finding a new site, immediately check if it can pair optimally with previous sites

Key Takeaway

🎯 Key Insight: By combining dynamic programming (to track optimal previous solutions) with sliding window (to find current solutions efficiently), we achieve optimal O(n) time complexity while making the best pairing decisions in real-time.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming with sliding window technique to achieve O(n) time complexity. The key insight is to maintain a DP array that tracks the shortest subarray with target sum found before each position, while using a sliding window to efficiently find current subarrays. This allows us to check for optimal pairings in real-time as we process the array.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Sliding Window (Optimal)	O(n)	O(n)	Use DP to track minimum subarray length ending at each position and sliding window for current subarray
Brute Force (Check All Subarray Pairs)	O(n⁴)	O(n²)	Generate all possible subarrays and check every non-overlapping pair

Dynamic Programming with Sliding Window (Optimal) — Algorithm Steps

Use sliding window to find subarrays with target sum
Maintain DP array tracking shortest subarray length ending before each position
For each valid subarray found, check if we can pair it with a previous one
Update the minimum total length and DP array as we progress

Visualization

Tap to expand

Step-by-Step Walkthrough

Sliding Window

Use two pointers to find subarrays with target sum

DP Tracking

Maintain shortest subarray found before each position

Optimal Pairing

When finding a valid subarray, check for optimal pairing

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int min(int a, int b) {
    return a < b ? a : b;
}

int minSumOfLengths(int* arr, int arrSize, int target) {
    int* dp = malloc((arrSize + 1) * sizeof(int));
    for (int i = 0; i <= arrSize; i++) {
        dp[i] = INT_MAX;
    }
    
    int left = 0;
    int currentSum = 0;
    int minTotalLength = INT_MAX;
    
    for (int right = 0; right < arrSize; right++) {
        currentSum += arr[right];
        
        // Shrink window if sum exceeds target
        while (currentSum > target && left <= right) {
            currentSum -= arr[left];
            left++;
        }
        
        // Found a subarray with target sum
        if (currentSum == target) {
            int currentLength = right - left + 1;
            
            // Check if we can pair with a previous subarray
            if (dp[left] != INT_MAX) {
                minTotalLength = min(minTotalLength, dp[left] + currentLength);
            }
            
            // Update dp array
            dp[right + 1] = min(dp[right], currentLength);
        } else {
            dp[right + 1] = dp[right];
        }
    }
    
    free(dp);
    return minTotalLength == INT_MAX ? -1 : minTotalLength;
}

int main() {
    int arr[] = {3,2,2,4,3};
    int target = 3;
    printf("%d\n", minSumOfLengths(arr, 5, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with sliding window technique

✓ Linear Growth

Space Complexity

O(n)

DP array to store minimum lengths at each position

⚡ Linearithmic Space

52.5K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler