Codestin Search App

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

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

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.

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
✓ 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	O(n log n)	O(n)	Use coordinate transformation and sorting to reduce search space

Brute Force (Check All Pairs) — Algorithm Steps

Initialize minimum distance to infinity and result pair to (-1, -1)
Use nested loops: outer loop for i from 0 to n-2, inner loop for j from i+1 to n-1
For each pair (i,j), calculate Manhattan distance: |nums1[i] - nums1[j]| + |nums2[i] - nums2[j]|
If current distance is smaller than minimum, update both minimum distance and result pair
If current distance equals minimum, keep the lexicographically smaller pair
Return the result pair

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first point and compare with all subsequent points

Calculate Distance

For each pair, compute Manhattan distance

Update Minimum

Keep track of the pair with smallest distance

Lexicographic Order

When distances are equal, choose lexicographically smaller pair

Code -

solution.c — C

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

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

int* solution(int* nums1, int* nums2, int n) {
    int minDist = INT_MAX;
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = -1;
    result[1] = -1;
    
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            int dist = abs_val(nums1[i] - nums1[j]) + abs_val(nums2[i] - nums2[j]);
            if (dist < minDist || (dist == minDist && (i < result[0] || (i == result[0] && j < result[1])))) {
                minDist = dist;
                result[0] = i;
                result[1] = j;
            }
        }
    }
    
    return result;
}

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²)

We check all possible pairs, which is n×(n-1)/2 = O(n²) comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track minimum distance and result pair

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler