Maximum Number of Non-Overlapping Subarrays With Sum Equals Target

Maximum Number of Non-Overlapping Subarrays With Sum Equals Target - Problem

Maximum Number of Non-Overlapping Subarrays With Sum Equals Target

You are given an array of integers nums and an integer target. Your goal is to find the maximum number of non-empty, non-overlapping subarrays such that each subarray has a sum equal to the target value.

Think of this as a greedy optimization problem: whenever you find a subarray that sums to the target, you should "claim" it immediately to maximize your total count. The key insight is that being greedy here actually leads to the optimal solution!

Example: If nums = [1,1,1,1,1] and target = 2, you can form 2 non-overlapping subarrays: [1,1] and [1,1], with one element left over.

Return the maximum number of such subarrays you can create.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,1,1,1], target = 2

› Output: 2

💡 Note: We can form 2 non-overlapping subarrays: [1,1] (indices 0-1) and [1,1] (indices 2-3), both with sum 2. The remaining element [1] cannot form a subarray with sum 2.

example_2.py — Mixed Values

$ Input: nums = [-1,1,1,1,-1,1], target = 0

› Output: 3

💡 Note: We can form 3 non-overlapping subarrays: [-1,1] (sum=0), [1,-1] (sum=0), and the single element [0] if it existed. Actually: [-1,1] (indices 0-1), [1,1,-1] (indices 2-4), giving us 2 subarrays. Wait, let me recalculate: [-1,1] (indices 0-1, sum=0), [1,1,-1,1] won't work. Better: [-1,1] (0-1), [1,-1] (2,4) doesn't work due to gap. Optimal is: [-1,1] and [1,1,-1] for 2 total, but greedy gives [-1,1], then [1,1,-1], then remaining [1]. Actually optimal answer is 3: [-1,1], [1,1,-1], [1] won't work. The correct answer is 2: [-1,1] and [1,1,-1].

example_3.py — No Valid Subarrays

$ Input: nums = [0,0,0], target = 1

› Output: 0

💡 Note: No subarray can sum to 1 since all elements are 0, so we return 0.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
0 ≤ target ≤ 10⁶
Subarrays must be non-empty and non-overlapping

Visualization

Tap to expand

Understanding the Visualization

Initialize Hunt

Start with empty treasure bag, tracking all coin counts seen (including 0 for empty bag)

Collect Coins

Add each coin to running total, checking if we can form target sum with previous position

Claim Treasure

When current_total - some_previous_total = target, immediately seal the treasure bag

Reset and Continue

Clear memory of previous totals and start fresh search from current position

Key Takeaway

🎯 Key Insight: The greedy approach works optimally because taking a subarray as soon as we find it never prevents us from finding a better solution later. This is due to the non-overlapping constraint - earlier decisions don't affect future possibilities.

Asked in

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

The optimal solution uses a greedy approach with prefix sums and hash set. As we iterate through the array, we maintain a running prefix sum and track seen prefix sums. When (current_prefix_sum - target) exists in our seen set, we've found a valid subarray and greedily claim it immediately. This greedy choice leads to the optimal solution with O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set with Prefix Sum (Optimal)	O(n)	O(n)	Use prefix sum and hash set to greedily find subarrays in one pass
Brute Force (Check All Subarrays)	O(2^n)	O(n²)	Try all possible combinations of non-overlapping subarrays

One-Pass Hash Set with Prefix Sum (Optimal) — Algorithm Steps

Initialize a set containing 0 (for subarrays starting from index 0)
Iterate through array maintaining running prefix sum
If (prefix_sum - target) exists in set, we found a valid subarray
Increment count, clear the set, add 0, and reset for next search
Otherwise, add current prefix_sum to set and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with prefix_sum = 0, seen = {0}, count = 0

Process Each Element

Add element to prefix_sum and check if (prefix_sum - target) exists in seen

Found Subarray

When found, increment count and reset seen set and prefix_sum

Continue

Add current prefix_sum to seen and continue to next element

Code -

solution.c — C

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

#define MAX_SIZE 100000

typedef struct {
    int values[MAX_SIZE];
    int size;
} Set;

void initSet(Set* set) {
    set->size = 0;
}

void addToSet(Set* set, int value) {
    for (int i = 0; i < set->size; i++) {
        if (set->values[i] == value) return;
    }
    set->values[set->size++] = value;
}

int containsInSet(Set* set, int value) {
    for (int i = 0; i < set->size; i++) {
        if (set->values[i] == value) return 1;
    }
    return 0;
}

int maxNonOverlapping(int* nums, int numsSize, int target) {
    int count = 0;
    int prefixSum = 0;
    Set seen;
    initSet(&seen);
    addToSet(&seen, 0); // Include 0 for subarrays starting from index 0
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        
        // If prefixSum - target is in seen, then there's a subarray
        // from some previous position to current position with sum = target
        if (containsInSet(&seen, prefixSum - target)) {
            count++;
            initSet(&seen);
            addToSet(&seen, 0); // Reset for next subarray search
            prefixSum = 0;
        } else {
            addToSet(&seen, prefixSum);
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", maxNonOverlapping(nums, numsSize, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash set operations

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n prefix sums in worst case

⚡ Linearithmic Space

89.2K Views

Medium-High Frequency

~18 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

One-Pass Hash Set with Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler