Widest Pair of Indices With Equal Range Sum

Widest Pair of Indices With Equal Range Sum - Problem

Given two binary arrays nums1 and nums2 of equal length, find the widest pair of indices (i, j) where i ≤ j such that the subarray sums are equal.

More formally, you need to find indices i and j such that:

nums1[i] + nums1[i+1] + ... + nums1[j] == nums2[i] + nums2[i+1] + ... + nums2[j]
The distance j - i + 1 is maximized

Example: If nums1 = [1,0,1] and nums2 = [0,1,1], then for indices (0,2): nums1[0:2] = 1+0+1 = 2 and nums2[0:2] = 0+1+1 = 2. The distance is 2-0+1 = 3.

Return the maximum distance of such a pair, or 0 if no valid pair exists.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,0,1], nums2 = [0,1,1]

› Output: 3

💡 Note: For the entire array (i=0, j=2): sum of nums1[0:2] = 1+0+1 = 2, sum of nums2[0:2] = 0+1+1 = 2. Distance = 2-0+1 = 3.

example_2.py — No Valid Pair

$ Input: nums1 = [1,1], nums2 = [0,0]

› Output: 0

💡 Note: No subarray pair has equal sums. nums1 subarrays have sums [1,1,2] while nums2 subarrays have sums [0,0,0].

example_3.py — Multiple Valid Pairs

$ Input: nums1 = [0,1,0,1], nums2 = [1,0,1,0]

› Output: 4

💡 Note: The entire array works: sum of nums1 = 2, sum of nums2 = 2. Distance = 3-0+1 = 4. This is the maximum possible.

Visualization

Tap to expand

Understanding the Visualization

Create difference array

For each position i, calculate diff[i] = nums1[i] - nums2[i]

Calculate prefix sums

Running sum of differences tells us the cumulative 'balance'

Use hash map

Store first occurrence of each prefix sum value

Find maximum distance

When prefix sum repeats, we found equal subarray sums

Key Takeaway

🎯 Key Insight: Transform the equal subarray sum problem into finding the widest span between identical prefix sum values in the difference array.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash operations

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n different prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
nums1.length == nums2.length
nums1[i] and nums2[i] are either 0 or 1

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses prefix sum transformation with a hash map. Key insight: if two subarrays have equal sums, their cumulative difference must return to a previously seen value. We track the first occurrence of each prefix sum difference and calculate the maximum distance when the same sum reappears. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check all possible pairs (i,j) and calculate subarray sums for each
Prefix Sum + Hash Map (Optimal)	O(n)	O(n)	Transform to difference array and find widest span with same prefix sum

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all possible starting positions i
For each i, iterate through all possible ending positions j >= i
Calculate sum of nums1[i:j+1] and nums2[i:j+1]
If sums are equal, update maximum distance
Return the maximum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Select start index i

Choose starting position for subarray

Select end index j

Choose ending position where j >= i

Calculate sums

Sum elements in both arrays from i to j

Compare and update

If sums equal, update max distance

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int widestPairBruteForce(int* nums1, int* nums2, int n) {
    int maxDistance = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int sum1 = 0, sum2 = 0;
            for (int k = i; k <= j; k++) {
                sum1 += nums1[k];
                sum2 += nums2[k];
            }
            if (sum1 == sum2) {
                maxDistance = max(maxDistance, j - i + 1);
            }
        }
    }
    
    return maxDistance;
}

int main() {
    int nums1[] = {1, 0, 1};
    int nums2[] = {0, 1, 1};
    printf("%d\n", widestPairBruteForce(nums1, nums2, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs to check, O(n) to calculate each sum

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for indices and sums

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
nums1.length == nums2.length
nums1[i] and nums2[i] are either 0 or 1

48.2K Views

Medium 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler