Beautiful Pairs

Beautiful Pairs - Problem

Array Math Divide and Conquer Geometry Sorting Ordered Set Hard

You are given two 0-indexed integer arrays nums1 and nums2 of the same length.

A pair of indices (i,j) is called beautiful if |nums1[i] - nums1[j]| + |nums2[i] - nums2[j]| is the smallest amongst all possible indices pairs where i < j.

Return the beautiful pair. In the case that there are multiple beautiful pairs, return the lexicographically smallest pair.

Note that |x| denotes the absolute value of x.

A pair of indices (i1, j1) is lexicographically smaller than (i2, j2) if i1 < i2 or i1 == i2 and j1 < j2.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2]

💡 Note: Check all pairs: (0,1) has distance |1-3| + |1-2| = 3, (0,2) has distance |1-2| + |1-3| = 3, (1,2) has distance |3-2| + |2-3| = 2. The minimum distance is 2 at indices (1,2).

Example 2 — Multiple Minimum Pairs

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

› Output: [0,1]

💡 Note: All points are identical, so all pairs have distance 0. Return the lexicographically smallest pair (0,1).

Example 3 — Negative Numbers

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

› Output: [0,1]

💡 Note: Only one pair (0,1) with distance |-1-2| + |1-(-1)| = 3 + 2 = 5.

Constraints

2 ≤ nums1.length == nums2.length ≤ 10⁵
-10⁴ ≤ nums1[i], nums2[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28

The key insight is recognizing this as a closest pair problem using Manhattan distance. The brute force approach checks all pairs in O(n²) time. The optimized approach uses sorting and geometric properties to prune impossible candidates, improving average case performance. Best approach depends on input size - brute force for small inputs, optimized for larger ones. Time: O(n²), Space: O(1) for brute force.

Common Approaches

✓ Stack

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

Brute Force

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

Generate all possible pairs (i,j) where i < j, calculate Manhattan distance for each pair, and keep track of the minimum distance pair. Return the lexicographically smallest among all minimum pairs.

Sort and Sweep

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

Sort the points by one coordinate and use sweep line technique to avoid checking all pairs. Still has quadratic worst case but performs better on average by pruning impossible candidates early.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nums1[1000];
static int nums2[1000];

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number (handle negative)
        int sign = 1;
        if (*p == '-') {
            sign = -1;
            p++;
        }
        
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        
        arr[(*size)++] = sign * num;
    }
}

int main() {
    char line1[10000], line2[10000];
    
    // Read first array
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    
    // Read second array  
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    int n1, n2;
    parseArray(line1, nums1, &n1);
    parseArray(line2, nums2, &n2);
    
    int n = n1; // Both arrays have same length
    
    int minDist = INT_MAX;
    int bestI = 0, bestJ = 1;
    
    // Try all pairs (i,j) where i < j
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int dist = abs(nums1[i] - nums1[j]) + abs(nums2[i] - nums2[j]);
            
            if (dist < minDist || (dist == minDist && (i < bestI || (i == bestI && j < bestJ)))) {
                minDist = dist;
                bestI = i;
                bestJ = j;
            }
        }
    }
    
    printf("[%d,%d]\n", bestI, bestJ);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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