Count the Number of Inversions - Problem

Count the Number of Inversions

You're given an integer n and a 2D array requirements, where each requirements[i] = [end_i, cnt_i] represents a constraint on the permutation.

What is an inversion?
In an array, an inversion is a pair of indices (i, j) where i < j but nums[i] > nums[j]. It's essentially when a larger element appears before a smaller one.

Your Goal:
Find how many permutations of [0, 1, 2, ..., n-1] satisfy ALL the given requirements. For each requirement [end_i, cnt_i], the subarray perm[0..end_i] must have exactly cnt_i inversions.

Since the answer can be very large, return it modulo 10⁹ + 7.

Example: If n=3 and requirements=[[2,2]], we need permutations where the first 3 elements have exactly 2 inversions. The permutation [2,1,0] works because it has inversions: (0,1), (0,2), (1,2) - but wait, that's 3 inversions, not 2!

Input & Output

example_1.py — Basic Case

$ Input: n = 3, requirements = [[2,2]]

› Output: 2

💡 Note: We need permutations of [0,1,2] where the first 3 elements have exactly 2 inversions. Valid permutations: [2,0,1] has inversions (0,1), (0,2) = 2 total. [1,2,0] has inversions (0,2), (1,2) = 2 total.

example_2.py — Multiple Requirements

$ Input: n = 3, requirements = [[0,0], [2,2]]

› Output: 1

💡 Note: First element (arr[0]) must create 0 inversions with itself (which is always true), and the entire array must have exactly 2 inversions. The permutation [0,2,1] satisfies both: arr[0..0] has 0 inversions, and arr[0..2] has 1 inversion at (1,2).

example_3.py — Impossible Case

$ Input: n = 2, requirements = [[0,1]]

› Output: 0

💡 Note: With only 1 element at position 0, it's impossible to have 1 inversion since inversions need at least 2 elements.

Constraints

2 ≤ n ≤ 300
0 ≤ requirements.length ≤ n
requirements[i] = [end_i, cnt_i]
0 ≤ end_i ≤ n - 1
0 ≤ cnt_i ≤ 400
All end_i are distinct

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses Dynamic Programming to build permutations incrementally. We maintain states dp[pos][inv] representing ways to place the first pos elements with exactly inv inversions. When placing an element at rank r in position p, it contributes (p-r) new inversions. Requirements are enforced by zeroing out invalid states at checkpoints, leading to O(n³ × max_inversions) time complexity.

Common Approaches

✓ Dynamic Programming (Optimal)

⏱️ Time: O(n³ × max_inversions) Space: O(n × max_inversions)

This approach uses dynamic programming to build valid permutations step by step. We maintain a DP state dp[pos][inversions] representing the number of ways to place the first 'pos' elements with exactly 'inversions' inversions. When placing the next element, we calculate how many new inversions it creates based on its position.

Generate All Permutations

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

This approach generates every possible permutation of [0,1,2,...,n-1] and for each permutation, counts the inversions in each required prefix to see if it matches the constraints. While conceptually simple, it's extremely inefficient.

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table: dp[pos][inv] = ways to place first pos elements with inv inversions
For each position from 0 to n-1, try placing each available element
When placing element val at position pos, it creates (val - rank) new inversions
Update DP state and check requirements at specified endpoints
Return dp[n][final_inversions] where final_inversions matches all requirements

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0][0] = 1 (0 elements, 0 inversions)

Place Elements

For each position, try placing available elements

Count Inversions

Calculate new inversions based on element rank

Check Requirements

Enforce constraints at specified endpoints

Combine Results

Sum all valid final states

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 300
#define MAX_INV 45000

static long long dp[MAX_N + 1][MAX_INV + 1];

int numberOfPermutations(int n, int requirements[][2], int reqSize) {
    int reqMap[MAX_N];
    for (int i = 0; i < MAX_N; i++) {
        reqMap[i] = -1;
    }
    
    for (int i = 0; i < reqSize; i++) {
        reqMap[requirements[i][0]] = requirements[i][1];
    }
    
    int maxInv = n * (n - 1) / 2;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= maxInv; j++) {
            dp[i][j] = 0;
        }
    }
    dp[0][0] = 1;
    
    for (int pos = 0; pos < n; pos++) {
        for (int inv = 0; inv <= maxInv; inv++) {
            if (dp[pos][inv] == 0) continue;
            
            for (int rank = 0; rank <= pos; rank++) {
                int newInv = inv + (pos - rank);
                if (newInv <= maxInv) {
                    dp[pos + 1][newInv] = (dp[pos + 1][newInv] + dp[pos][inv]) % MOD;
                }
            }
        }
        
        if (reqMap[pos] != -1) {
            int requiredInv = reqMap[pos];
            for (int inv = 0; inv <= maxInv; inv++) {
                if (inv != requiredInv) {
                    dp[pos + 1][inv] = 0;
                }
            }
        }
    }
    
    long long result = 0;
    for (int inv = 0; inv <= maxInv; inv++) {
        result = (result + dp[n][inv]) % MOD;
    }
    
    return (int) result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    int requirements[1000][2];
    int reqSize = 0;
    
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    
    if (*ptr == '[') {
        ptr++;
        while (*ptr && *ptr != ']') {
            while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\t')) ptr++;
            
            if (*ptr == '[') {
                char *end;
                int a = strtol(ptr + 1, &end, 10);
                if (*end == ',') {
                    end++;
                    int b = strtol(end, &end, 10);
                    if (*end == ']') {
                        requirements[reqSize][0] = a;
                        requirements[reqSize][1] = b;
                        reqSize++;
                        ptr = end + 1;
                    } else {
                        ptr++;
                    }
                } else {
                    ptr++;
                }
            } else if (*ptr == ']') {
                break;
            } else {
                ptr++;
            }
        }
    }
    
    printf("%d\n", numberOfPermutations(n, requirements, reqSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × max_inversions)

O(n) positions × O(n) elements to place × O(n) possible positions × O(max_inversions) states

⚠ Quadratic Growth

Space Complexity

O(n × max_inversions)

DP table storing states for each position and inversion count

⚡ Linearithmic Space

18.7K Views

Medium Frequency

~35 min Avg. Time

485 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

Count the Number of Inversions - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler