Maximum Distance in Arrays - Practice Coding Problems

Maximum Distance in Arrays - Problem

Array Greedy Medium

Maximum Distance in Arrays - Find the greatest possible distance between elements from different sorted arrays.

You are given m arrays, where each array is sorted in ascending order. Your task is to pick exactly two integers from two different arrays (one element from each array) and calculate the distance between them.

The distance between two integers a and b is defined as their absolute difference |a - b|.

Goal: Return the maximum possible distance you can achieve.

Example: Given arrays [[1,2,3], [4,5], [1,2,3]], you could pick 1 from the first array and 5 from the second array for a distance of 4.

Input & Output

example_1.py — Basic Case

$ Input: arrays = [[1,2,3],[4,5],[1,2,3]]

› Output: 4

💡 Note: One way to reach the maximum distance 4 is to pick 1 in the first or third array and pick 5 in the second array.

example_2.py — Simple Case

$ Input: arrays = [[1],[1]]

› Output: 0

💡 Note: Since we can only pick from different arrays and both arrays contain the same element, the maximum distance is 0.

example_3.py — Larger Range

$ Input: arrays = [[1,4,5],[0,2]]

› Output: 5

💡 Note: We can pick 0 from the second array and 5 from the first array to get the maximum distance of 5.

Constraints

m == arrays.length
2 ≤ m ≤ 10⁵
1 ≤ arrays[i].length ≤ 500
-10⁴ ≤ arrays[i][j] ≤ 10⁴
arrays[i] is sorted in ascending order
There will be at most 5 × 10⁵ integers in all the arrays

Visualization

Tap to expand

Understanding the Visualization

Scout All Ranges

Identify the global lowest valley (minimum) and highest peak (maximum)

Calculate Distances

For each range, find the maximum distance using global extremes

Avoid Same Range

Ensure we pick peaks from different mountain ranges

Key Takeaway

🎯 Key Insight: The maximum distance must be between the smallest element of one array and the largest element of a different array, since all arrays are sorted in ascending order.

Asked in

G Google 45 a Amazon 38 f Meta 29 Apple 22

The optimal solution uses a greedy approach with the key insight that since arrays are sorted, we only need to consider the first and last elements of each array. We find the global minimum and maximum in one pass, then calculate the maximum distance by considering the extremes from different arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Greedy (Optimal)	O(m)	O(1)	Track global min/max in one pass, then find maximum distance in second pass
Brute Force (Nested Loops)	O(n²)	O(1)	Compare every element from every array with every element from every other array

Two-Pass Greedy (Optimal) — Algorithm Steps

First pass: Find the global minimum and maximum across all arrays
Second pass: For each array, calculate the maximum distance using global min/max
Handle edge case where the current array contains the global min or max
Return the maximum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Identify global minimum and maximum values

Second Pass

Calculate maximum distance for each array using global extremes

Handle Edge Cases

Skip arrays that contain the global min/max when calculating

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

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

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

int maxDistance(int** arrays, int* arraySizes, int arrayCount) {
    // First pass: find global min and max
    int globalMin = INT_MAX;
    int globalMax = INT_MIN;
    
    for (int i = 0; i < arrayCount; i++) {
        globalMin = min(globalMin, arrays[i][0]);
        globalMax = max(globalMax, arrays[i][arraySizes[i] - 1]);
    }
    
    // Second pass: find maximum distance
    int maxDist = 0;
    
    for (int i = 0; i < arrayCount; i++) {
        int currMin = arrays[i][0];
        int currMax = arrays[i][arraySizes[i] - 1];
        
        if (currMin != globalMin) {
            maxDist = max(maxDist, abs_val(currMax - globalMin));
        }
        
        if (currMax != globalMax) {
            maxDist = max(maxDist, abs_val(globalMax - currMin));
        }
    }
    
    return maxDist;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m)

Two passes through m arrays, where m is the number of arrays

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler