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.

A pair of indices (i, j), where 0 <= i < nums1.length and 0 <= j < nums2.length, is valid if both i <= j and nums1[i] <= nums2[j]. The distance of the pair is j - i.

Return the maximum distance of any valid pair (i, j). If there are no valid pairs, return 0.

An array arr is non-increasing if arr[i-1] >= arr[i] for every 1 <= i < arr.length.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: The valid pairs are (0,0), (2,2), and (2,3). The pair (2,3) has the maximum distance of 3-2=1.

Example 2 — No Valid Pairs

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

› Output: 2

💡 Note: Valid pairs are (3,3) and (3,4). The maximum distance is 4-3=1. Actually, (3,3) gives 0 and (3,4) gives 1, but we also have (2,4) since 19≤25, giving distance 2.

Example 3 — Single Elements

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

› Output: 0

💡 Note: Only one valid pair (0,0) with distance 0-0=0.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is leveraging the non-increasing property of both arrays. The optimal two pointers approach starts from opposite ends and moves strategically based on the comparison. Time: O(n+m), Space: O(1).

Common Approaches

✓ Optimized

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

Brute Force

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

For each index i in nums1, check all indices j >= i in nums2. If nums1[i] <= nums2[j], calculate distance j-i and track maximum.

Two Pointers

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

Since both arrays are non-increasing, we can use two pointers starting from the beginning of nums1 and end of nums2. Move pointers strategically to find the maximum valid distance.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int val, i, j;
} Cell;

typedef struct {
    int val, origIdx;
} Query;

typedef struct {
    int* parent;
    int* rank;
    int* componentSize;
    int size;
} UnionFind;

UnionFind* createUF(int size) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(size * sizeof(int));
    uf->rank = (int*)malloc(size * sizeof(int));
    uf->componentSize = (int*)malloc(size * sizeof(int));
    uf->size = size;
    for (int i = 0; i < size; i++) {
        uf->parent[i] = i;
        uf->rank[i] = 1;
        uf->componentSize[i] = 1;
    }
    return uf;
}

int findUF(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = findUF(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionUF(UnionFind* uf, int x, int y) {
    int px = findUF(uf, x), py = findUF(uf, y);
    if (px == py) return;
    if (uf->rank[px] < uf->rank[py]) {
        int temp = px; px = py; py = temp;
    }
    uf->parent[py] = px;
    uf->componentSize[px] += uf->componentSize[py];
    if (uf->rank[px] == uf->rank[py]) {
        uf->rank[px]++;
    }
}

int getSizeUF(UnionFind* uf, int x) {
    return uf->componentSize[findUF(uf, x)];
}

int compareCells(const void* a, const void* b) {
    Cell* ca = (Cell*)a;
    Cell* cb = (Cell*)b;
    return ca->val - cb->val;
}

int compareQueries(const void* a, const void* b) {
    Query* qa = (Query*)a;
    Query* qb = (Query*)b;
    return qa->val - qb->val;
}

int* solution(int** grid, int gridSize, int* gridColSize, int* queries, int queriesSize, int* returnSize) {
    int m = gridSize, n = gridColSize[0];
    
    // Create list of all cells
    Cell* cells = (Cell*)malloc(m * n * sizeof(Cell));
    int cellCount = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cells[cellCount++] = (Cell){grid[i][j], i, j};
        }
    }
    
    qsort(cells, cellCount, sizeof(Cell), compareCells);
    
    // Create indexed queries
    Query* indexedQueries = (Query*)malloc(queriesSize * sizeof(Query));
    for (int i = 0; i < queriesSize; i++) {
        indexedQueries[i] = (Query){queries[i], i};
    }
    qsort(indexedQueries, queriesSize, sizeof(Query), compareQueries);
    
    UnionFind* uf = createUF(m * n);
    bool** added = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        added[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int* answer = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    int cellIdx = 0;
    
    for (int q = 0; q < queriesSize; q++) {
        int queryVal = indexedQueries[q].val;
        int origIdx = indexedQueries[q].origIdx;
        
        // Add all cells with value < queryVal
        while (cellIdx < cellCount && cells[cellIdx].val < queryVal) {
            int i = cells[cellIdx].i, j = cells[cellIdx].j;
            added[i][j] = true;
            
            // Union with adjacent added cells
            for (int d = 0; d < 4; d++) {
                int ni = i + directions[d][0], nj = j + directions[d][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && added[ni][nj]) {
                    unionUF(uf, i * n + j, ni * n + nj);
                }
            }
            cellIdx++;
        }
        
        // Check if (0,0) is accessible
        if (added[0][0]) {
            answer[origIdx] = getSizeUF(uf, 0);
        } else {
            answer[origIdx] = 0;
        }
    }
    
    // Cleanup
    free(cells);
    free(indexedQueries);
    for (int i = 0; i < m; i++) {
        free(added[i]);
    }
    free(added);
    free(uf->parent);
    free(uf->rank);
    free(uf->componentSize);
    free(uf);
    
    return answer;
}

int parseGrid(char* line, int*** grid, int* gridSize, int** gridColSize) {
    *gridSize = 0;
    *gridColSize = NULL;
    *grid = NULL;
    
    if (strlen(line) <= 2) return 0;
    
    // Count rows
    int rows = 1;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && i > 0 && line[i-1] != '[') rows++;
    }
    
    *grid = (int**)malloc(rows * sizeof(int*));
    *gridColSize = (int*)malloc(rows * sizeof(int));
    *gridSize = rows;
    
    int row = 0;
    char* token = strtok(line, "[]");
    while (token != NULL && row < rows) {
        if (strlen(token) > 1 && token[0] != ',') {
            // Count numbers in this row
            int cols = 1;
            for (int i = 0; token[i]; i++) {
                if (token[i] == ',') cols++;
            }
            
            (*grid)[row] = (int*)malloc(cols * sizeof(int));
            (*gridColSize)[row] = cols;
            
            char* num_token = strtok(token, ",");
            int col = 0;
            while (num_token != NULL && col < cols) {
                (*grid)[row][col] = atoi(num_token);
                col++;
                num_token = strtok(NULL, ",");
            }
            row++;
        }
        token = strtok(NULL, "[]");
    }
    
    return 1;
}

int parseQueries(char* line, int** queries, int* queriesSize) {
    *queries = NULL;
    *queriesSize = 0;
    
    if (strlen(line) <= 2) return 0;
    
    // Remove brackets
    line[strlen(line)-1] = '\0';
    line++;
    
    // Count queries
    int count = 1;
    for (int i = 0; line[i]; i++) {
        if (line[i] == ',') count++;
    }
    
    *queries = (int*)malloc(count * sizeof(int));
    *queriesSize = count;
    
    char* token = strtok(line, ",");
    int i = 0;
    while (token != NULL && i < count) {
        (*queries)[i] = atoi(token);
        i++;
        token = strtok(NULL, ",");
    }
    
    return 1;
}

int main() {
    char line1[10000], line2[10000];
    
    if (fgets(line1, sizeof(line1), stdin) == NULL) return 1;
    if (fgets(line2, sizeof(line2), stdin) == NULL) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int** grid;
    int gridSize;
    int* gridColSize;
    int* queries;
    int queriesSize;
    
    if (!parseGrid(line1, &grid, &gridSize, &gridColSize)) return 1;
    if (!parseQueries(line2, &queries, &queriesSize)) return 1;
    
    int returnSize;
    int* result = solution(grid, gridSize, gridColSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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