K Inverse Pairs Array - Practice Coding Problems

K Inverse Pairs Array - Problem

Dynamic Programming Hard

Imagine you're arranging numbers from 1 to n in a specific way to create exactly k inverse pairs. An inverse pair occurs when a larger number appears before a smaller number in the array - like having 3 before 1 in [3, 2, 1]. Your Challenge: Given two integers n and k, determine how many different arrays can be formed using numbers 1 to n such that there are exactly k inverse pairs. For example, with n=3 and k=1, the arrays [1,3,2], [2,1,3], and [3,1,2] each have exactly one inverse pair. Since the result can be enormous, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic case with small numbers

$ Input: n = 3, k = 0

› Output: 1

💡 Note: Only the array [1,2,3] has exactly 0 inverse pairs (it's already sorted)

example_2.py — Multiple valid arrangements

$ Input: n = 3, k = 1

› Output: 2

💡 Note: Arrays [1,3,2], [2,1,3] each have exactly 1 inverse pair: (3,2) and (2,1) respectively

example_3.py — Maximum inversions case

$ Input: n = 4, k = 6

› Output: 1

💡 Note: Only [4,3,2,1] has the maximum 6 inverse pairs: (4,3), (4,2), (4,1), (3,2), (3,1), (2,1)

Constraints

1 ≤ n ≤ 1000
0 ≤ k ≤ 1000
Maximum possible inverse pairs for n numbers is n×(n-1)/2
Result must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Understand Inverse Pairs

An inverse pair (i,j) means arr[i] > arr[j] but i < j - larger number appears before smaller

Recursive Structure

When placing largest number n at position i, it creates i inverse pairs with all previous smaller numbers

DP Transition

dp[n][k] = sum of dp[n-1][k-i] for i from 0 to min(k, n-1)

Optimization

Use prefix sum to compute each dp[i][j] in O(1) instead of O(k) time

Key Takeaway

🎯 Key Insight: When placing the largest number n, its position determines exactly how many new inverse pairs are created, allowing us to break down the problem recursively and solve it efficiently with dynamic programming.

Asked in

G Google 24 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal approach uses dynamic programming with prefix sum optimization. Key insight: when placing the largest number n in position i, it creates exactly i inverse pairs with smaller numbers. Build solution bottom-up using dp[i][j] = ways to arrange i numbers with j inversions, achieving O(n×k) time and O(k) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n²)	O(n!)	Generate all permutations and count inverse pairs for each
Dynamic Programming (Basic Memoization)	O(n² × k)	O(n × k)	Use recursion with memoization to avoid redundant calculations
Dynamic Programming (Optimized Bottom-Up)	O(n × k)	O(k)	Build solution bottom-up using optimized DP with space optimization

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all n! permutations of numbers 1 to n
For each permutation, count the number of inverse pairs
Count how many permutations have exactly k inverse pairs
Return the count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of numbers 1 to n

Count Inversions

For each permutation, count pairs where larger number comes before smaller

Filter Results

Keep only permutations with exactly k inverse pairs

Code -

solution.c — C

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

#define MOD 1000000007

int countInversions(int* arr, int n) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i] > arr[j]) count++;
        }
    }
    return count;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int permute(int* arr, int start, int end, int k, int* result) {
    if (start == end) {
        if (countInversions(arr, end + 1) == k) {
            (*result) = ((*result) + 1) % MOD;
        }
        return 0;
    }
    
    for (int i = start; i <= end; i++) {
        swap(&arr[start], &arr[i]);
        permute(arr, start + 1, end, k, result);
        swap(&arr[start], &arr[i]);
    }
    return 0;
}

int kInversePairs(int n, int k) {
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }
    
    int result = 0;
    permute(nums, 0, n - 1, k, &result);
    
    free(nums);
    return result;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    printf("%d\n", kInversePairs(n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

O(n!) to generate all permutations, O(n²) to count inverse pairs in each

⚠ Quadratic Growth

Space Complexity

O(n!)

Storage for all permutations plus recursion stack

⚠ Quadratic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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 (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler