Maximum Distance Between a Pair of Values

Maximum Distance Between a Pair of Values - Problem

You are given two non-increasing 0-indexed integer arrays nums1 and nums2. Your goal is to find the maximum distance between a pair of valid indices.

A pair of indices (i, j) is considered valid if:

0 <= i < nums1.length and 0 <= j < nums2.length
i <= j (index constraint)
nums1[i] <= nums2[j] (value constraint)

The distance of a valid pair is defined as j - i.

Return the maximum distance of any valid pair. If no valid pairs exist, return 0.

Note: An array is non-increasing if arr[i-1] >= arr[i] for every valid index.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [55,30,5,4,2], nums2 = [100,20,10,10,5]

› Output: 2

💡 Note: The optimal pair is (i=2, j=4): nums1[2]=5 ≤ nums2[4]=5, and 2 ≤ 4, giving distance 4-2=2. Other valid pairs like (0,0) give smaller distances.

example_2.py — No Valid Pairs

$ Input: nums1 = [30,29,19,5], nums2 = [25,25,25,25,25]

› Output: 2

💡 Note: Valid pairs are (2,2), (2,3), (2,4), (3,3), (3,4). The maximum distance is achieved by (2,4) or (3,4), both giving distance 2.

example_3.py — Single Elements

$ Input: nums1 = [5], nums2 = [3]

› Output: 0

💡 Note: Only one possible pair (0,0), but 5 > 3, so no valid pairs exist. Return 0.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Place one inspector at the start of first row, another at the end of second row

Valid Connection

If current buildings can connect, record distance and try for longer bridge by moving second inspector left

Invalid Connection

If buildings can't connect, move first inspector right to find a shorter building

Optimal Result

Continue until inspectors meet or exhaust possibilities, keeping track of maximum distance

Key Takeaway

🎯 Key Insight: The two pointers technique leverages the non-increasing property of both arrays to efficiently find the maximum valid distance without checking all possible pairs.

Time & Space Complexity

Time Complexity

⏱️

O(n log m)

For each element in nums1 (n elements), we perform binary search on nums2 (log m time)

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds and maximum distance

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁵
nums1 and nums2 are both non-increasing

Asked in

a Amazon 15 G Google 8 ⊞ Microsoft 5 f Meta 3

The optimal solution uses two pointers to achieve O(n+m) time complexity. Key insight: since both arrays are non-increasing, we can strategically move pointers to find the maximum distance efficiently. Start with pointer i at nums1[0] and j at nums2[end], then move pointers based on the validity of the current pair.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search Approach	O(n log m)	O(1)	For each element in nums1, binary search for the rightmost valid position in nums2
Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to efficiently find maximum distance in O(n+m) time
Brute Force (Nested Loops)	O(n × m)	O(1)	Check all valid pairs and find maximum distance

Binary Search Approach — Algorithm Steps

Initialize maxDistance = 0
For each index i in nums1:
Use binary search on nums2[i:] to find rightmost j where nums2[j] >= nums1[i]
If found, update maxDistance = max(maxDistance, j - i)
Return maxDistance

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Binary Search

For each i in nums1, search nums2[i:] for rightmost valid position

Search Process

Use binary search to find rightmost j where nums2[j] >= nums1[i]

Update Maximum

Calculate distance j-i and update maximum if larger

Code -

solution.c — C

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

int binarySearchRightmost(int* arr, int arrSize, int target, int startIdx) {
    int left = startIdx, right = arrSize - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] >= target) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int findMaxDistance(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int maxDistance = 0;
    
    for (int i = 0; i < nums1Size; i++) {
        int j = binarySearchRightmost(nums2, nums2Size, nums1[i], i);
        if (j != -1) {
            int distance = j - i;
            if (distance > maxDistance) {
                maxDistance = distance;
            }
        }
    }
    
    return maxDistance;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log m)

For each element in nums1 (n elements), we perform binary search on nums2 (log m time)

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds and maximum distance

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁵
nums1 and nums2 are both non-increasing

28.4K Views

Medium Frequency

~18 min Avg. Time

892 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

Binary Search Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler