Reverse Pairs

Reverse Pairs - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

Given an integer array nums, return the number of reverse pairs in the array.

A reverse pair is a pair (i, j) where:

0 <= i < j < nums.length and
nums[i] > 2 * nums[j]

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,3,2,3,1]

› Output: 2

💡 Note: The reverse pairs are (1,4) where nums[1]=3 > 2*nums[4]=2*1=2, and (3,4) where nums[3]=3 > 2*nums[4]=2*1=2

Example 2 — No Pairs

$ Input: nums = [2,4,3,5,1]

› Output: 3

💡 Note: Pairs: (0,4) since 2>2*1=2 is false, (1,4) since 4>2*1=2 is true, (2,4) since 3>2*1=2 is true, (3,4) since 5>2*1=2 is true

Example 3 — Minimum Size

$ Input: nums = [5,1]

› Output: 1

💡 Note: Only one pair (0,1): 5 > 2*1 = 2, so count = 1

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 A Amazon 15 F Facebook 12

The key insight is to use modified merge sort to count reverse pairs efficiently during the merge process. The optimal approach uses divide and conquer with merge sort to achieve O(n log n) time complexity by counting cross-pairs between subarrays. Time: O(n log n), Space: O(n)

Common Approaches

✓ Binary Search with Sorting

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

Create pairs of (value, original_index), sort by value, then for each element use binary search to find how many elements to its right satisfy the reverse pair condition.

Brute Force

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

For each element at index i, check all elements at indices j > i to see if nums[i] > 2 * nums[j]. Count all such valid pairs.

Merge Sort with Counting

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

Implement merge sort but during the merge step, count how many elements from the right subarray form reverse pairs with elements from the left subarray. This avoids redundant comparisons.

Binary Search with Sorting — Algorithm Steps

Create array of (value, index) pairs
Sort by values in ascending order
For each element, binary search for elements > 2 * current_value with larger original indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort

Create sorted array while maintaining original indices

Use binary search to find valid pairs efficiently

Count

Count pairs where index constraint is satisfied

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if ((long long)nums[i] > 2LL * nums[j]) {
                count++;
            }
        }
    }
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For each of n elements, binary search takes O(log n), but checking indices takes O(n)

⚠ Quadratic Growth

Space Complexity

O(n)

Extra array to store (value, index) pairs

✓ Linear Space

180.0K Views

Medium Frequency

~35 min Avg. Time

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

Binary Search with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler