K Inverse Pairs Array

K Inverse Pairs Array - Problem

Dynamic Programming Hard

For an integer array nums, an inverse pair is a pair of integers [i, j] where 0 <= i < j < nums.length and nums[i] > nums[j].

Given two integers n and k, return the number of different arrays consisting of numbers from 1 to n such that there are exactly k inverse pairs.

Since the answer can be huge, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, k = 0

› Output: 1

💡 Note: Only one array [1,2,3] has 0 inverse pairs (already sorted)

Example 2 — One Inversion

$ Input: n = 3, k = 1

› Output: 2

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

Example 3 — Edge Case

$ Input: n = 4, k = 2

› Output: 5

💡 Note: Multiple arrays possible with exactly 2 inverse pairs

Constraints

1 ≤ n ≤ 1000
0 ≤ k ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that when placing the i-th largest number, it can create 0 to min(i-1, k) new inverse pairs depending on its position. The optimal approach uses dynamic programming with prefix sum optimization. Time: O(nk), Space: O(k)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

2D Dynamic Programming

⏱️ Time: O(n² × k) Space: O(n × k)

Use bottom-up DP where dp[i][j] = number of ways to arrange i numbers with exactly j inverse pairs. Fill table iteratively using recurrence relation.

Generate All Permutations

⏱️ Time: O(n! × n²) Space: O(n)

Generate every possible permutation of numbers 1 to n, then count inverse pairs in each permutation. Keep track of how many permutations have exactly k inverse pairs.

Optimized DP with Sliding Window

⏱️ Time: O(n × k) Space: O(k)

Use the same DP recurrence but optimize the inner loop using sliding window technique with prefix sums. This reduces time complexity from O(n²k) to O(nk).

Recursive with Memoization

⏱️ Time: O(n² × k) Space: O(n × k)

Build arrays incrementally by deciding where to place each number. Use memoization to store results for (remaining numbers, remaining inversions) states.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_MEMO 100000

typedef struct {
    int remaining;
    int inversions;
    int result;
} MemoEntry;

static MemoEntry memo[MAX_MEMO];
static int memoSize = 0;

int findMemo(int remaining, int inversions) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].remaining == remaining && memo[i].inversions == inversions) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int remaining, int inversions, int result) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].remaining = remaining;
        memo[memoSize].inversions = inversions;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int remaining, int inversions) {
    if (remaining == 0) {
        return inversions == 0 ? 1 : 0;
    }
    if (inversions < 0) {
        return 0;
    }
    
    int cached = findMemo(remaining, inversions);
    if (cached != -1) {
        return cached;
    }
    
    long long result = 0;
    int maxPos = remaining < (inversions + 1) ? remaining : (inversions + 1);
    
    for (int pos = 0; pos < maxPos; pos++) {
        result = (result + dp(remaining - 1, inversions - pos)) % MOD;
    }
    
    addMemo(remaining, inversions, (int)result);
    return (int)result;
}

int solution(int n, int k) {
    memoSize = 0;
    return dp(n, k);
}

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

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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