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

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

You are given an array of integers arr and an integer target.

You have to find two non-overlapping sub-arrays of arr each with a sum equal to 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.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Only sub-arrays with sum 3 are [3] at index 0 and [3] at index 4. Total length = 1 + 1 = 2.

Example 2 — Multiple Options

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

› Output: 2

💡 Note: Sub-arrays with sum 7: [7] at index 0 (length 1), [3,4] at indices 1-2 (length 2), [7] at index 3 (length 1). Best pair: [7] + [7] = 1 + 1 = 2.

Example 3 — No Solution

$ Input: arr = [1,1,1,1], target = 3

› Output: -1

💡 Note: Sub-arrays with sum 3: [1,1,1] at indices 0-2 and [1,1,1] at indices 1-3. These overlap, so no valid pair exists.

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 1000
1 ≤ target ≤ 300

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to use sliding window technique combined with dynamic programming to efficiently find valid sub-arrays and track the best non-overlapping combinations. The optimal approach uses sliding window with prefix tracking to achieve O(n) time complexity by maintaining information about the shortest sub-array found before each position.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 2d

⏱️ Time: N/A Space: N/A

Brute Force - Check All Pairs

⏱️ Time: O(n⁴) Space: O(n²)

For each possible sub-array with target sum, check all other non-overlapping sub-arrays with target sum. Keep track of the minimum total length found.

Dynamic Programming Approach

⏱️ Time: O(n²) Space: O(n)

Build a DP array where dp[i] represents the minimum length of sub-array ending at position i with target sum, then combine with previous results.

Sliding Window with Prefix Tracking

⏱️ Time: O(n) Space: O(n)

Use sliding window technique to efficiently find all sub-arrays with target sum, while maintaining information about the shortest sub-array found before each position.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int minSubArrayLen(int* arr, int n, int target, int* subarray_lens) {
    // Find all possible subarray lengths that sum to target
    for (int i = 0; i < n; i++) {
        subarray_lens[i] = INT_MAX;
    }
    
    int min_len = INT_MAX;
    
    // Check all possible subarrays
    for (int i = 0; i < n; i++) {
        int sum = 0;
        for (int j = i; j < n; j++) {
            sum += arr[j];
            if (sum == target) {
                int len = j - i + 1;
                if (len < min_len) {
                    min_len = len;
                }
                // Store minimum length ending at position j
                if (len < subarray_lens[j]) {
                    subarray_lens[j] = len;
                }
            } else if (sum > target) {
                break;
            }
        }
    }
    
    return min_len == INT_MAX ? -1 : min_len;
}

int solution(int* arr, int n, int target) {
    int* left_min = (int*)malloc(n * sizeof(int));
    int* right_min = (int*)malloc(n * sizeof(int));
    int* temp_lens = (int*)malloc(n * sizeof(int));
    
    // Initialize arrays
    for (int i = 0; i < n; i++) {
        left_min[i] = INT_MAX;
        right_min[i] = INT_MAX;
    }
    
    // Fill left_min: minimum subarray length ending at or before position i
    int current_min = INT_MAX;
    for (int i = 0; i < n; i++) {
        // Find subarray ending exactly at position i
        int sum = 0;
        for (int j = i; j >= 0; j--) {
            sum += arr[j];
            if (sum == target) {
                int len = i - j + 1;
                if (len < current_min) {
                    current_min = len;
                }
                break;
            } else if (sum > target) {
                break;
            }
        }
        left_min[i] = current_min;
    }
    
    // Fill right_min: minimum subarray length starting at or after position i
    current_min = INT_MAX;
    for (int i = n - 1; i >= 0; i--) {
        // Find subarray starting exactly at position i
        int sum = 0;
        for (int j = i; j < n; j++) {
            sum += arr[j];
            if (sum == target) {
                int len = j - i + 1;
                if (len < current_min) {
                    current_min = len;
                }
                break;
            } else if (sum > target) {
                break;
            }
        }
        right_min[i] = current_min;
    }
    
    int result = INT_MAX;
    
    // Try all possible split points
    for (int i = 0; i < n - 1; i++) {
        if (left_min[i] != INT_MAX && right_min[i + 1] != INT_MAX) {
            int total = left_min[i] + right_min[i + 1];
            if (total < result) {
                result = total;
            }
        }
    }
    
    free(left_min);
    free(right_min);
    free(temp_lens);
    
    return result == INT_MAX ? -1 : result;
}

int main() {
    char line[10000];
    int arr[1000];
    int n = 0;
    int target;
    
    // Read array line
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    // Parse array [1,2,3,4,5] format
    int i = 0;
    while (line[i] && line[i] != '[') i++;
    if (line[i] == '[') i++;
    
    int num = 0;
    int sign = 1;
    int reading_num = 0;
    
    while (line[i] && line[i] != ']') {
        if (line[i] >= '0' && line[i] <= '9') {
            num = num * 10 + (line[i] - '0');
            reading_num = 1;
        } else if (line[i] == '-') {
            sign = -1;
            reading_num = 1;
        } else if (line[i] == ',' || line[i] == ']') {
            if (reading_num) {
                arr[n++] = sign * num;
                num = 0;
                sign = 1;
                reading_num = 0;
            }
        }
        i++;
    }
    if (reading_num) {
        arr[n++] = sign * num;
    }
    
    // Read target
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    target = 0;
    sign = 1;
    i = 0;
    while (line[i] && (line[i] == ' ' || line[i] == '\t')) i++;
    if (line[i] == '-') {
        sign = -1;
        i++;
    }
    while (line[i] >= '0' && line[i] <= '9') {
        target = target * 10 + (line[i] - '0');
        i++;
    }
    target *= sign;
    
    int result = solution(arr, n, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

24.5K Views

Medium Frequency

~25 min Avg. Time

890 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