Beautiful Pairs - Practice Coding Problems

Beautiful Pairs - Problem

Array Math Divide and Conquer Geometry Sorting Ordered Set Hard

Beautiful Pairs is a fascinating geometric optimization problem that challenges you to find the pair of points with minimum Manhattan distance.

You are given two 0-indexed integer arrays nums1 and nums2 of the same length. Think of these as coordinates - each index i represents a point (nums1[i], nums2[i]) in 2D space.

A pair of indices (i, j) where i < j is called beautiful if the Manhattan distance between points i and j is the smallest among all possible pairs. The Manhattan distance is calculated as: |nums1[i] - nums1[j]| + |nums2[i] - nums2[j]|

🎯 Your Goal: Return the lexicographically smallest beautiful pair. If multiple pairs have the same minimum distance, return the one with the smallest i, and if there's still a tie, the smallest j.

Example: If nums1 = [1, 2, 3] and nums2 = [1, 2, 3], the points are (1,1), (2,2), (3,3). The distances are: (0,1)→2, (0,2)→4, (1,2)→2. The minimum distance is 2, and (0,1) is lexicographically smaller than (1,2).

Input & Output

example_1.py — Basic Case

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

› Output: [0, 1]

💡 Note: Points are (1,1), (2,2), (3,3). Distance between indices 0,1 is |1-2|+|1-2|=2. Distance between indices 0,2 is |1-3|+|1-3|=4. Distance between indices 1,2 is |2-3|+|2-3|=2. Both (0,1) and (1,2) have minimum distance 2, but (0,1) is lexicographically smaller.

example_2.py — Same Points

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

› Output: [0, 2]

💡 Note: Points are (1,1), (1,2), (2,1). Distance between indices 0,1 is |1-1|+|1-2|=1. Distance between indices 0,2 is |1-2|+|1-1|=1. Distance between indices 1,2 is |1-2|+|2-1|=2. Both (0,1) and (0,2) have minimum distance 1, but (0,1) is lexicographically smaller than (0,2), so we return (0,1). Wait, let me recalculate: (0,1) comes before (0,2) lexicographically, so the answer should be [0,1]. Actually, let me check: distance(0,1)=1, distance(0,2)=1, distance(1,2)=2. Between (0,1) and (0,2), we choose (0,1) as it's lexicographically smaller.

example_3.py — All Different Distances

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

› Output: [0, 2]

💡 Note: Points are (0,0), (5,0), (3,4). Distance between indices 0,1 is |0-5|+|0-0|=5. Distance between indices 0,2 is |0-3|+|0-4|=7. Distance between indices 1,2 is |5-3|+|0-4|=6. The minimum distance is 5, so we return [0,1].

Visualization

Tap to expand

Understanding the Visualization

Plot Points

Each index i represents a point (nums1[i], nums2[i]) on a 2D grid

Calculate Distances

For each pair, measure Manhattan distance: horizontal + vertical movement

Find Minimum

Identify pair(s) with the smallest total block distance

Break Ties

When multiple pairs have same distance, choose lexicographically smallest

Key Takeaway

🎯 Key Insight: Manhattan distance represents real-world "city block" distance. The optimal solution transforms coordinates to use geometric properties, achieving O(n log n) complexity instead of O(n²) brute force.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, closest pair finding is also O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Need to store transformed coordinates and maintain original indices

⚡ Linearithmic Space

Constraints

2 ≤ nums1.length == nums2.length ≤ 10⁵
-10⁴ ≤ nums1[i], nums2[i] ≤ 10⁴
All points (nums1[i], nums2[i]) are treated as distinct even if coordinates are the same

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal approach uses coordinate transformation to convert Manhattan distance to Chebyshev distance, then applies a divide-and-conquer closest pair algorithm achieving O(n log n) time complexity. For smaller inputs, the O(n²) brute force approach is simpler and sufficient.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Sorting and Geometric Properties	O(n log n)	O(n)	Use coordinate transformation and sorting to reduce search space
Brute Force (Check All Pairs)	O(n²)	O(1)	Check every possible pair (i,j) and find the one with minimum Manhattan distance

Optimized with Sorting and Geometric Properties — Algorithm Steps

Transform coordinates: u = x + y, v = x - y (45-degree rotation)
Create list of transformed points with original indices
Sort points by u-coordinate, then by v-coordinate
Use the fact that minimum Manhattan distance corresponds to minimum Chebyshev distance in transformed space
Apply divide-and-conquer or sweepline technique to find closest pair
Convert back to original indices and return lexicographically smallest

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform Coordinates

Convert (x,y) to (u,v) where u=x+y, v=x-y

Sort Points

Sort by u-coordinate, then by v-coordinate

Divide & Conquer

Recursively find closest pairs in left and right halves

Merge Step

Check pairs across the dividing line efficiently

Code -

solution.c — C

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

typedef struct {
    int u, v, index;
} Point;

int minDist = INT_MAX;
int result[2];

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

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

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

int compare_u(const void* a, const void* b) {
    Point* pa = (Point*)a;
    Point* pb = (Point*)b;
    if (pa->u != pb->u) return pa->u - pb->u;
    return pa->v - pb->v;
}

int compare_v(const void* a, const void* b) {
    Point* pa = (Point*)a;
    Point* pb = (Point*)b;
    return pa->v - pb->v;
}

int closestPairRec(Point* px, Point* py, int n) {
    if (n <= 3) {
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int dist = max_val(abs_val(px[i].u - px[j].u), abs_val(px[i].v - px[j].v));
                int minIdx = min_val(px[i].index, px[j].index);
                int maxIdx = max_val(px[i].index, px[j].index);
                
                if (dist < minDist || (dist == minDist && (minIdx < result[0] || (minIdx == result[0] && maxIdx < result[1])))) {
                    minDist = dist;
                    result[0] = minIdx;
                    result[1] = maxIdx;
                }
            }
        }
        return minDist;
    }
    
    int mid = n / 2;
    Point midpoint = px[mid];
    
    Point* pyl = (Point*)malloc(n * sizeof(Point));
    Point* pyr = (Point*)malloc(n * sizeof(Point));
    int nl = 0, nr = 0;
    
    for (int i = 0; i < n; i++) {
        if (py[i].u <= midpoint.u) {
            pyl[nl++] = py[i];
        } else {
            pyr[nr++] = py[i];
        }
    }
    
    int dl = closestPairRec(px, pyl, mid);
    int dr = closestPairRec(px + mid, pyr, n - mid);
    
    int d = min_val(dl, dr);
    
    Point* strip = (Point*)malloc(n * sizeof(Point));
    int stripSize = 0;
    
    for (int i = 0; i < n; i++) {
        if (abs_val(py[i].u - midpoint.u) < d) {
            strip[stripSize++] = py[i];
        }
    }
    
    for (int i = 0; i < stripSize; i++) {
        for (int j = i + 1; j < stripSize && (strip[j].v - strip[i].v) < d; j++) {
            int dist = max_val(abs_val(strip[i].u - strip[j].u), abs_val(strip[i].v - strip[j].v));
            int minIdx = min_val(strip[i].index, strip[j].index);
            int maxIdx = max_val(strip[i].index, strip[j].index);
            
            if (dist < minDist || (dist == minDist && (minIdx < result[0] || (minIdx == result[0] && maxIdx < result[1])))) {
                minDist = dist;
                result[0] = minIdx;
                result[1] = maxIdx;
            }
        }
    }
    
    free(pyl);
    free(pyr);
    free(strip);
    
    return minDist;
}

int* solution(int* nums1, int* nums2, int n) {
    Point* points = (Point*)malloc(n * sizeof(Point));
    
    for (int i = 0; i < n; i++) {
        points[i].u = nums1[i] + nums2[i];
        points[i].v = nums1[i] - nums2[i];
        points[i].index = i;
    }
    
    qsort(points, n, sizeof(Point), compare_u);
    
    minDist = INT_MAX;
    result[0] = n;
    result[1] = n;
    
    Point* py = (Point*)malloc(n * sizeof(Point));
    for (int i = 0; i < n; i++) {
        py[i] = points[i];
    }
    qsort(py, n, sizeof(Point), compare_v);
    
    closestPairRec(points, py, n);
    
    free(points);
    free(py);
    
    int* res = (int*)malloc(2 * sizeof(int));
    res[0] = result[0];
    res[1] = result[1];
    return res;
}

int main() {
    int nums1[] = {1, 2, 3};
    int nums2[] = {1, 2, 3};
    int n = 3;
    
    int* result = solution(nums1, nums2, n);
    printf("[%d, %d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, closest pair finding is also O(n log n)

⚡ Linearithmic

Space Complexity

O(n)

Need to store transformed coordinates and maintain original indices

⚡ Linearithmic Space

Constraints

2 ≤ nums1.length == nums2.length ≤ 10⁵
-10⁴ ≤ nums1[i], nums2[i] ≤ 10⁴
All points (nums1[i], nums2[i]) are treated as distinct even if coordinates are the same

52.1K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Optimized with Sorting and Geometric Properties — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler