Count the Number of Inversions - Practice Coding Problems

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 must create 0 inversions (so it's the minimum), and total must be 2. Only [0,2,1] works: 0 inversions at position 0, and inversions (1,2) gives 1 total... wait, this needs recalculation.

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

Understanding the Visualization

Start Empty

Begin with no one seated - 1 way to have 0 inversions

Seat First Person

Place person with skill 0, 1, or 2 in first seat - creates different inversion potentials

Add Second Person

Each new person can sit ahead of or behind existing people, creating specific numbers of inversions

Check Constraints

At required checkpoints, eliminate arrangements that don't meet inversion requirements

Continue Building

Keep adding people while tracking valid arrangements until all seats are filled

Key Takeaway

🎯 Key Insight: Build permutations incrementally using DP, where placing element k at position p with r smaller elements already placed contributes exactly (k-r) new inversions. This allows us to efficiently count valid arrangements without generating all permutations.

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³ × max_inversions)	O(n × max_inversions)	Build permutations incrementally while tracking inversion counts using DP
Generate All Permutations	O(n! × n²)	O(n)	Generate all n! permutations and check each against all requirements

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

int numberOfPermutations(int n, int requirements[][2], int reqSize) {
    int reqMap[MAX_N];
    memset(reqMap, -1, sizeof(reqMap));
    
    for (int i = 0; i < reqSize; i++) {
        reqMap[requirements[i][0]] = requirements[i][1];
    }
    
    int maxInv = n * (n - 1) / 2;
    long long dp[MAX_N + 1][MAX_INV + 1];
    memset(dp, 0, sizeof(dp));
    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 requirements[1][2] = {{2, 2}};
    printf("%d\n", numberOfPermutations(3, requirements, 1));
    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.6K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler