Maximum Distance in Arrays

Maximum Distance in Arrays - Problem

Array Greedy Medium

You are given m arrays, where each array is sorted in ascending order. You can pick up two integers from two different arrays (each array picks one) and calculate the distance. We define the distance between two integers a and b to be their absolute difference |a - b|.

Return the maximum distance.

Input & Output

Example 1 — 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 — Different Arrays

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

› Output: 0

💡 Note: Both arrays contain only 1, so the maximum distance is |1-1| = 0.

Example 3 — Negative Numbers

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

› Output: 6

💡 Note: Maximum distance is achieved by picking -2 from the third array and 4 from the second array, giving |4-(-2)| = 6.

Constraints

m == arrays.length
2 ≤ m ≤ 10⁵
1 ≤ arrays[i].length ≤ 500
-10⁴ ≤ arrays[i][j] ≤ 10⁴
arrays[i] is sorted in ascending order.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 Apple 8

The key insight is that maximum distance always comes from pairing extreme values (min and max) from different arrays. Since arrays are sorted, we only need to compare the first and last elements. Best approach uses min-max optimization tracking global extremes. Time: O(m), Space: O(1)

Common Approaches

✓ Optimized Dp

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

Brute Force

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

Check all possible pairs of elements from different arrays and find the maximum absolute difference. For each element in each array, compare it with all elements in all other arrays.

Min-Max Optimization

⏱️ Time: O(m) Space: O(1)

Since arrays are sorted, the maximum distance will always come from comparing the minimum of one array with the maximum of another. We only need to check extremes.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

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

int solution(int** arrays, int* array_sizes, int num_arrays) {
    int max_distance = 0;
    
    for (int i = 0; i < num_arrays; i++) {
        for (int j = 0; j < num_arrays; j++) {
            if (i != j) {
                for (int x = 0; x < array_sizes[i]; x++) {
                    for (int y = 0; y < array_sizes[j]; y++) {
                        max_distance = max(max_distance, abs_diff(arrays[i][x], arrays[j][y]));
                    }
                }
            }
        }
    }
    
    return max_distance;
}

int parse_arrays(char* input, int*** arrays, int** array_sizes, int* num_arrays) {
    // Skip leading whitespace and '['
    char* p = input;
    while (*p == ' ' || *p == '\t' || *p == '\n') p++;
    if (*p != '[') return -1;
    p++;
    
    // Count arrays first
    *num_arrays = 0;
    char* temp = p;
    int bracket_count = 0;
    while (*temp) {
        if (*temp == '[') {
            if (bracket_count == 0) (*num_arrays)++;
            bracket_count++;
        } else if (*temp == ']') {
            bracket_count--;
        }
        temp++;
    }
    
    if (*num_arrays == 0) return -1;
    
    *arrays = (int**)malloc(*num_arrays * sizeof(int*));
    *array_sizes = (int*)malloc(*num_arrays * sizeof(int));
    
    int array_idx = 0;
    
    while (*p && array_idx < *num_arrays) {
        // Skip whitespace and commas
        while (*p == ' ' || *p == '\t' || *p == '\n' || *p == ',') p++;
        
        if (*p == ']') break; // End of main array
        
        if (*p != '[') return -1; // Should be start of sub-array
        p++;
        
        // Count elements in this array
        int count = 0;
        char* temp2 = p;
        int in_number = 0;
        while (*temp2 && *temp2 != ']') {
            if (*temp2 >= '0' && *temp2 <= '9' || *temp2 == '-') {
                if (!in_number) {
                    count++;
                    in_number = 1;
                }
            } else if (*temp2 == ',' || *temp2 == ' ') {
                in_number = 0;
            }
            temp2++;
        }
        
        (*array_sizes)[array_idx] = count;
        (*arrays)[array_idx] = (int*)malloc(count * sizeof(int));
        
        // Parse the numbers
        int elem_idx = 0;
        while (*p && *p != ']' && elem_idx < count) {
            while (*p == ' ' || *p == '\t' || *p == ',') p++;
            
            if (*p == ']') break;
            
            // Parse number
            int num = 0;
            int negative = 0;
            if (*p == '-') {
                negative = 1;
                p++;
            }
            
            while (*p >= '0' && *p <= '9') {
                num = num * 10 + (*p - '0');
                p++;
            }
            
            if (negative) num = -num;
            (*arrays)[array_idx][elem_idx] = num;
            elem_idx++;
        }
        
        // Skip to end of this array
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        
        array_idx++;
    }
    
    return 0;
}

int main() {
    char input[100000];
    if (!fgets(input, sizeof(input), stdin)) {
        return 1;
    }
    
    int** arrays;
    int* array_sizes;
    int num_arrays;
    
    if (parse_arrays(input, &arrays, &array_sizes, &num_arrays) != 0) {
        return 1;
    }
    
    int result = solution(arrays, array_sizes, num_arrays);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < num_arrays; i++) {
        free(arrays[i]);
    }
    free(arrays);
    free(array_sizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

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