Minimum Threshold for Inversion Pairs Count

Minimum Threshold for Inversion Pairs Count - Problem

You are tasked with analyzing inversion pairs in an array with a twist - we need to find pairs that are "close enough" in value!

Given an array of integers nums and an integer k, an inversion pair with threshold x is defined as a pair of indices (i, j) such that:

i < j (left element comes before right element)
nums[i] > nums[j] (left element is greater - this creates the inversion)
nums[i] - nums[j] ≤ x (the difference is at most the threshold)

Your goal is to find the minimum threshold such that there are at least k inversion pairs with that threshold. If it's impossible to find k such pairs, return -1.

Example: In array [4, 1, 3, 2] with threshold 2, pairs (0,1), (0,3), (2,3) are valid inversion pairs because 4>1 (diff=3≤2 ❌), 4>2 (diff=2≤2 ✓), 3>2 (diff=1≤2 ✓).

Input & Output

example_1.py — Python

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

› Output: 2

💡 Note: With threshold 2: pairs (0,3) where 4>2 and 4-2=2≤2, and (2,3) where 3>2 and 3-2=1≤2. Total: 2 pairs ≥ k=2.

example_2.py — Python

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

› Output: -1

💡 Note: Array is already sorted, no inversion pairs exist (i < j but nums[i] ≤ nums[j] for all valid i,j).

example_3.py — Python

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

› Output: 2

💡 Note: With threshold 2: pairs (0,1) 5>1 diff=4>2❌, (0,3) 5>2 diff=3>2❌, (0,4) 5>3 diff=2≤2✓, (2,3) 4>2 diff=2≤2✓, (2,4) 4>3 diff=1≤2✓. Total: 3 pairs ≥ k=3.

Visualization

Tap to expand

Understanding the Visualization

Identify Inversions

Find all pairs where earlier score > later score

Apply Threshold

Only count pairs where difference ≤ threshold

Binary Search

Find minimum threshold that gives ≥k pairs

Optimize Counting

Use merge sort to count pairs efficiently

Key Takeaway

🎯 Key Insight: Binary search works because if threshold x allows ≥k pairs, any larger threshold will also work. We efficiently count pairs for each candidate threshold to find the minimum viable one.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to find all possible thresholds, then O(n²) for each threshold to count pairs

⚠ Quadratic Growth

Space Complexity

O(n²)

Store all possible threshold values (up to n² differences)

⚠ Quadratic Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ n(n-1)/2
All elements in nums are distinct

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses binary search on the answer combined with efficient pair counting. Since if threshold x works, any larger threshold also works, we can binary search for the minimum valid threshold. For each candidate threshold, we count inversion pairs efficiently using techniques like merge sort, achieving O(n log n log(max_diff)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(n²)	Try all possible thresholds by checking all inversion pairs
Binary Search + Efficient Counting	O(n log n log(max_diff))	O(n)	Binary search on threshold value with optimized pair counting

Brute Force (Nested Loops) — Algorithm Steps

Find all possible threshold values (differences between inverted pairs)
Sort these threshold values
For each threshold, count valid inversion pairs
Return the first threshold that gives at least k pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Thresholds

Find all possible differences between inverted pairs

Sort Thresholds

Sort thresholds in ascending order

Count Pairs

For each threshold, count valid inversion pairs

Find Minimum

Return first threshold with ≥k pairs

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int minimumThreshold(int* nums, int numsSize, int k) {
    int* thresholds = malloc(numsSize * numsSize * sizeof(int));
    int thresholdCount = 0;
    
    // Collect all possible thresholds
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] > nums[j]) {
                thresholds[thresholdCount++] = nums[i] - nums[j];
            }
        }
    }
    
    if (thresholdCount == 0) {
        free(thresholds);
        return -1;
    }
    
    qsort(thresholds, thresholdCount, sizeof(int), compare);
    
    // Try each threshold
    for (int t = 0; t < thresholdCount; t++) {
        int count = 0;
        for (int i = 0; i < numsSize; i++) {
            for (int j = i + 1; j < numsSize; j++) {
                if (nums[i] > nums[j] && nums[i] - nums[j] <= thresholds[t]) {
                    count++;
                }
            }
        }
        
        if (count >= k) {
            int result = thresholds[t];
            free(thresholds);
            return result;
        }
    }
    
    free(thresholds);
    return -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to find all possible thresholds, then O(n²) for each threshold to count pairs

⚠ Quadratic Growth

Space Complexity

O(n²)

Store all possible threshold values (up to n² differences)

⚠ Quadratic Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ n(n-1)/2
All elements in nums are distinct

42.0K Views

Medium Frequency

~35 min Avg. Time

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler