Number of permutation with K inversions
Last Updated :
08 Mar, 2025
We are given two numbers n and k, the task is to find how many permutations of the first n number have exactly k inversion. Two elements in a sequence form an inversion if the smaller element appears before the larger element.
Examples:
Input: n = 3, k = 1
Output: 2
Explanation: Total Permutation of first 3 numbers are 123, 132, 213, 231, 312, 321
Permutation with 1 inversion: 132 and 213
Input: n = 3, k = 3
Output: 1
Explanation: Permutation with 3 inversions: 321
Using Recursion - O(n! * k) Time and O(n) Space
Base Cases:
- If n == 0, no permutations are possible, so return 0.
- If k == 0, there is exactly one permutation (the sorted order), so return 1.
Recursive Relation:
- For each possible position i where the nth element can be placed (where i ranges from 0 to min(k, n-1)), we recursively call the function to calculate the number of permutations of n-1 elements with k-i inversions. This represents placing the
nth element in a way that creates i inversions.
countPermWithkInversions(n, k) = Σ(countPermWithkInversions(n-1, k-i)) for i = 0 to min(k, n-1)
C++
// C++ code to count permutations with exactly
// k inversions using Recursion
#include <iostream>
using namespace std;
int countPermWithkInversions(int n, int k) {
// Base cases
// no permutations possible with 0 elements
if (n == 0) return 0;
// Only one way to have 0 inversions: sorted order
if (k == 0) return 1;
// Initialize result for this recursive step
int result = 0;
// Recursively sum up all valid counts
// by placing the nth largest element
// in positions that create the
// required inversion counts
for (int i = 0; i <= min(k, n - 1); i++) {
result += countPermWithkInversions(n - 1, k - i);
}
return result;
}
int main() {
int n = 4;
int k = 2;
cout << countPermWithkInversions(n, k);
return 0;
}
// Java code to count permutations with
// exactly k inversions using Recursion
class GfG {
static int countPermWithkInversions(int n, int k) {
// Base cases
// no permutations possible with 0 elements
if (n == 0) return 0;
// Only one way to have 0 inversions: sorted order
if (k == 0) return 1;
// Initialize result for this recursive step
int result = 0;
// Recursively sum up all valid counts
// by placing the nth largest element
// in positions that create the
// required inversion counts
for (int i = 0; i <= Math.min(k, n - 1); i++) {
result += countPermWithkInversions(n - 1, k - i);
}
return result;
}
public static void main(String[] args) {
int n = 4;
int k = 2;
System.out.println(countPermWithkInversions(n, k));
}
}
# Python code to count permutations with exactly
# k inversions using Recursion
def countPermWithkInversions(n, k):
# Base cases
# no permutations possible with 0 elements
if n == 0:
return 0
# Only one way to have 0 inversions: sorted order
if k == 0:
return 1
# Initialize result for this recursive step
result = 0
# Recursively sum up all valid counts
# by placing the nth largest element
# in positions that create the
# required inversion counts
for i in range(min(k, n - 1) + 1):
result += countPermWithkInversions(n - 1, k - i)
return result
if __name__ == "__main__":
n = 4
k = 2
print(countPermWithkInversions(n, k))
// C# code to count permutations with exactly
// k inversions using Recursion
using System;
class GfG {
static int countPermWithkInversions(int n, int k) {
// Base cases
// no permutations possible with 0 elements
if (n == 0) return 0;
// Only one way to have 0 inversions: sorted order
if (k == 0) return 1;
// Initialize result for this recursive step
int result = 0;
// Recursively sum up all valid counts
// by placing the nth largest element
// in positions that create the
// required inversion counts
for (int i = 0; i <= Math.Min(k, n - 1); i++) {
result += countPermWithkInversions(n - 1, k - i);
}
return result;
}
static void Main() {
int n = 4;
int k = 2;
Console.WriteLine(countPermWithkInversions(n, k));
}
}
// Javascript code to count permutations with
// exactly k inversions using Recursion
function countPermWithkInversions(n, k) {
// Base cases
// no permutations possible with 0 elements
if (n === 0) return 0;
// Only one way to have 0 inversions: sorted order
if (k === 0) return 1;
// Initialize result for this recursive step
let result = 0;
// Recursively sum up all valid counts
// by placing the nth largest element
// in positions that create the
// required inversion counts
for (let i = 0; i <= Math.min(k, n - 1); i++) {
result += countPermWithkInversions(n - 1, k - i);
}
return result;
}
const n = 4;
const k = 2;
console.log(countPermWithkInversions(n, k));
Using Top-Down DP (Memoization) – O(n*k*k) Time and O(n*k) Space
The above recursive solution satisfies two key properties of Dynamic Programming, enabling us to use memoization for an optimized approach.
1. Optimal Substructure
We solve the problem of counting permutations with exactly k inversions by breaking it into subproblems involving fewer elements and inversions. Specifically, if we have n elements and k required inversions, we can compute it by trying positions for the largest element in a way that contributes to the inversion count.
The recursive relation is:
- countPermWithkInversions(n, k) = Σ countPermWithkInversions(n-1, k-i)
Here, we consider placing the largest element in positions that create i inversions, where i ranges from 0 to min(k, n-1).
2. Overlapping Subproblems:
Many subproblems are computed multiple times when finding permutations for smaller subsets and inversion counts. For example, while calculating the result for (n, k), subproblems for (n-1, k-i) are encountered repeatedly.
We use a 2D array memo of size (n+1) x (k+1), initialized to -1, to store results of subproblems. If a result is already stored in memo[n][k], we return it directly, avoiding redundant calculations.
C++
// C++ code to find number of permutation
// with k inversion using Memoization
#include <bits/stdc++.h>
using namespace std;
// Helper function for recursive computation
int kInversionsHelper(int n, int k,
vector<vector<int>>& memo) {
// Base case: If there are no elements,
// no permutations are possible
if (n == 0) return 0;
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
if (k == 0) return 1;
// Check if the result is already
// computed (memoization)
if (memo[n][k] != -1) return memo[n][k];
int result = 0;
// Loop through possible inversion counts
// for the nth largest element
for (int i = 0; i <= min(k, n - 1); i++) {
// Recursively count permutations for the
// remaining elements and inversions
result = (result +
kInversionsHelper(n - 1, k - i, memo));
}
return memo[n][k] = result;
}
// Function to count permutations with k inversions
int countPermWithkInversions(int n, int k) {
// Initialize memoization table with -1
// to indicate uncomputed values
vector<vector<int>> memo(n + 1, vector<int>(k + 1, -1));
return kInversionsHelper(n, k, memo);
}
int main() {
int n = 4;
int k = 2;
cout << countPermWithkInversions(n, k);
return 0;
}
// Java code to find number of permutation
// with k inversions using Memoization
import java.util.Arrays;
class GfG {
// Helper function for recursive computation
static int kInversionsHelper(int n, int k, int[][] memo) {
// Base case: If there are no elements,
// no permutations are possible
if (n == 0) return 0;
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
if (k == 0) return 1;
// Check if the result is already
// computed (memoization)
if (memo[n][k] != -1) return memo[n][k];
int result = 0;
// Loop through possible inversion counts
// for the nth largest element
for (int i = 0; i <= Math.min(k, n - 1); i++) {
// Recursively count permutations for the
// remaining elements and inversions
result = (result
+ kInversionsHelper(n - 1, k - i, memo));
}
return memo[n][k] = result;
}
// Function to count permutations with k inversions
static int countPermWithkInversions(int n, int k) {
// Initialize memoization table with -1
// to indicate uncomputed values
int[][] memo = new int[n + 1][k + 1];
for (int[] row : memo) {
Arrays.fill(row, -1);
}
return kInversionsHelper(n, k, memo);
}
public static void main(String[] args) {
int n = 4;
int k = 2;
System.out.println(countPermWithkInversions(n, k));
}
}
# Python code to find number of permutation
# with k inversions using Memoization
def kInversionsHelper(n, k, memo):
# Base case: If there are no elements,
# no permutations are possible
if n == 0:
return 0
# Base case: If k is 0, only one way to
# have 0 inversions: sorted order
if k == 0:
return 1
# Check if the result is already
# computed (memoization)
if memo[n][k] != -1:
return memo[n][k]
result = 0
# Loop through possible inversion counts
# for the nth largest element
for i in range(min(k, n - 1) + 1):
# Recursively count permutations for the
# remaining elements and inversions
result = (result + kInversionsHelper(n - 1, k - i, memo))
memo[n][k] = result
return result
def countPermWithkInversions(n, k):
# Initialize memoization table with -1
# to indicate uncomputed values
memo = [[-1 for _ in range(k + 1)] for _ in range(n + 1)]
return kInversionsHelper(n, k, memo)
if __name__ == "__main__":
n = 4
k = 2
print(countPermWithkInversions(n, k))
// C# code to find number of permutation
// with k inversions using Memoization
using System;
class GfG {
// Helper function for recursive computation
static int kInversionsHelper(int n, int k, int[,] memo) {
// Base case: If there are no elements,
// no permutations are possible
if (n == 0) return 0;
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
if (k == 0) return 1;
// Check if the result is already
// computed (memoization)
if (memo[n, k] != -1) return memo[n, k];
int result = 0;
// Loop through possible inversion counts
// for the nth largest element
for (int i = 0; i <= Math.Min(k, n - 1); i++) {
// Recursively count permutations for the
// remaining elements and inversions
result = (result + kInversionsHelper(n - 1, k - i, memo));
}
return memo[n, k] = result;
}
static int countPermWithkInversions(int n, int k) {
// Initialize memoization table with -1
// to indicate uncomputed values
int[,] memo = new int[n + 1, k + 1];
for (int i = 0; i < memo.GetLength(0); i++) {
for (int j = 0; j < memo.GetLength(1); j++) {
memo[i, j] = -1;
}
}
return kInversionsHelper(n, k, memo);
}
static void Main() {
int n = 4;
int k = 2;
Console.WriteLine(countPermWithkInversions(n, k));
}
}
// JavaScript code to find number of permutation
// with k inversions using Memoization
function kInversionsHelper(n, k, memo) {
// Base case: If there are no elements,
// no permutations are possible
if (n === 0)
return 0;
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
if (k === 0)
return 1;
// Check if the result is already
// computed (memoization)
if (memo[n][k] !== -1)
return memo[n][k];
let result = 0;
// Loop through possible inversion counts
// for the nth largest element
for (let i = 0; i <= Math.min(k, n - 1); i++) {
// Recursively count permutations for the
// remaining elements and inversions
result = (result
+ kInversionsHelper(n - 1, k - i, memo));
}
memo[n][k] = result;
return result;
}
function countPermWithkInversions(n, k) {
// Initialize memoization table with -1
// to indicate uncomputed values
const memo = Array.from({length : n + 1},
() => Array(k + 1).fill(-1));
return kInversionsHelper(n, k, memo);
}
const n = 4;
const k = 2;
console.log(countPermWithkInversions(n, k));
Using Bottom-Up DP (Tabulation) – O(n*k*k) Time and O(n*k) Space
We create a 2D array dp of size (n + 1)*(k + 1), where the state dp[l][r] represents the number of permutations of l elements with exactly r inversions.
Base Case: dp[l][0] = 1 for all l, since there's only one way to have zero inversions-by arranging elements in sorted order.
For each element count l from 1 to n:
- For each inversion count r from 1 to k, calculate the number of valid permutations.
- To compute dp[l][r], we iterate over all possible positions of the largest element, which can create up to min(r, l-1) inversions, summing up the results from previous states
This relation fills the DP table by counting valid permutations based on subproblems:
- dp[l][r] = sum of dp[l-1][r-i] for all valid i.
The final result is stored in dp[n][k], representing the total permutations of n elements with exactly k inversions.
C++
// C++ code to find number of permutation
// with K inversions using Tabulation
#include <bits/stdc++.h>
using namespace std;
int countPermWithkInversions(int n, int k) {
// Initialize a 2D table for dynamic programming
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
for (int l = 0; l <= n; l++) {
dp[l][0] = 1;
}
// Fill the table using the tabulation method
for (int l = 1; l <= n; l++) {
for (int r = 1; r <= k; r++) {
for (int i = 0; i <= min(r, l - 1); i++) {
// Count permutations for the remaining
// elements and inversions
dp[l][r] = (dp[l][r] + dp[l - 1][r - i]);
}
}
}
return dp[n][k];
}
int main() {
int n = 4;
int k = 2;
cout << countPermWithkInversions(n, k);
return 0;
}
// Java code to find number of permutation
// with K inversions using Tabulation
import java.util.Arrays;
class GfG {
static int countPermWithkInversions(int n, int k) {
// Initialize a 2D table for dynamic programming
int[][] dp = new int[n + 1][k + 1];
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
for (int l = 0; l <= n; l++) {
dp[l][0] = 1;
}
// Fill the table using the tabulation method
for (int l = 1; l <= n; l++) {
for (int r = 1; r <= k; r++) {
for (int i = 0; i <= Math.min(r, l - 1); i++) {
// Count permutations for the remaining
// elements and inversions
dp[l][r] = (dp[l][r] + dp[l - 1][r - i]);
}
}
}
return dp[n][k];
}
public static void main(String[] args) {
int n = 4;
int k = 2;
System.out.println(countPermWithkInversions(n, k));
}
}
# Python code to find number of permutation
# with k inversions using Tabulation
def countPermWithkInversions(n, k):
# Initialize a 2D table for dynamic programming
dp = [[0] * (k + 1) for _ in range(n + 1)]
# Base case: If k is 0, only one way to
# have 0 inversions: sorted order
for l in range(n + 1):
dp[l][0] = 1
# Fill the table using the tabulation method
for l in range(1, n + 1):
for r in range(1, k + 1):
for i in range(min(r, l - 1) + 1):
# Count permutations for the remaining
# elements and inversions
dp[l][r] = (dp[l][r] + dp[l - 1][r - i])
return dp[n][k]
if __name__ == "__main__":
n = 4
k = 2
print(countPermWithkInversions(n, k))
// C# code to find number of permutation
// with k inversions using Tabulation
using System;
class GfG {
static int countPermWithkInversions(int n, int k) {
// Initialize a 2D table for dynamic programming
int[,] dp = new int[n + 1, k + 1];
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
for (int l = 0; l <= n; l++) {
dp[l, 0] = 1;
}
// Fill the table using the tabulation method
for (int l = 1; l <= n; l++) {
for (int r = 1; r <= k; r++) {
for (int i = 0; i <= Math.Min(r, l - 1); i++) {
// Count permutations for the remaining
// elements and inversions
dp[l, r] = (dp[l, r] + dp[l - 1, r - i]);
}
}
}
return dp[n, k];
}
static void Main() {
int n = 4;
int k = 2;
Console.WriteLine(countPermWithkInversions(n, k));
}
}
// JavaScript code to find number of permutation
// with k inversions using Tabulation
function countPermWithkInversions(n, k) {
// Initialize a 2D table for dynamic programming
const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(0));
// Base case: If k is 0, only one way to
// have 0 inversions: sorted order
for (let l = 0; l <= n; l++) {
dp[l][0] = 1;
}
// Fill the table using the tabulation method
for (let l = 1; l <= n; l++) {
for (let r = 1; r <= k; r++) {
for (let i = 0; i <= Math.min(r, l - 1); i++) {
// Count permutations for the remaining
// elements and inversions
dp[l][r] = (dp[l][r] + dp[l - 1][r - i]);
}
}
}
return dp[n][k];
}
let n = 4;
let k = 2;
console.log(countPermWithkInversions(n, k));
Time Complexity: O(n*k*k), where n is the number of elements and k is the number of inversions, due to the nested loops iterating through n, k, and possible inversions.
Auxiliary Space: O(n*k), because we maintain a 2D table of size (n+1)×(k+1) to store the computed values for dynamic programming.
Similar Reads
Number of permutation with K inversions | Set 2
Given two integers N and K, the task is to count the number of permutations of the first N natural numbers having exactly K inversions. Since the count can be very large, print it modulo 109 + 7. An inversion is defined as a pair a[i], a[j] such that a[i] > a[j] and i < j. Examples: Input: N =
8 min read
Find a permutation of N natural numbers with K inversions
Given two integers N and K, the task is to find a permutation of first N natural numbers with exactly K inversions. Examples : Input: N = 5, K = 4Output: 5 1 2 3 4 Explanation: In the above permutation P, the pairs (i, j) such that i < j and P[i] > P[j] are (0, 1), (0, 2), (0, 3), and (0, 4).
9 min read
Find the number of good permutations
Given two integers N and K. The task is to find the number of good permutations of the first N natural numbers. A permutation is called good if there exist at least N - K indices i (1 ? i ? N) such that Pi = i. Examples: Input: N = 4, K = 1 Output: 1 {1, 2, 3, 4} is the only possible good permutatio
6 min read
Distinct permutations of a number
Given an integer N, the task is to print all distinct permutations of the number N. Examples: Input: N = 133Output: 133 313 331Explanation:There are a total of 6 permutations, which are [133, 313, 331, 133, 313, 331].Out of all these permutations, distinct permutations are [133, 313, 331]. Input: N
9 min read
Count the number of special permutations
Given two positive integers n and k, the task is to count the number of special permutations. A special permutation P is defined as a permutation of first n natural numbers in which there exists at least (n - k) indices such that Pi = i. Prerequisite: Derangements Examples: Input: n = 4, k = 2 Outpu
15+ min read
Find the good permutation of first N natural numbers
Given an integer N, the task is to print a good permutation of first N natural numbers. Let's denote the ith element of the permutation be pi. A good permutation is a permutation such that for all 1 ? i ? N the following equations hold true, ppi = ipi != i Basically above expressions mean, no value
4 min read
Number of Transpositions in a Permutation
Cycle notation is a compact way to represent a permutation by breaking it down into cycles. A cycle represents a set of elements that are permuted (or swapped) among each other.Examples:Let us consider the permutation p = [5, 1, 4, 2, 3] of [1, 2, 3, 4, 5], the elements are moved as 1 → 5, 5 → 3, 3
6 min read
Count inversions in a permutation of first N natural numbers
Given an array, arr[] of size N denoting a permutation of numbers from 1 to N, the task is to count the number of inversions in the array. Note: Two array elements a[i] and a[j] form an inversion if a[i] > a[j] and i < j. Examples: Input: arr[] = {2, 3, 1, 5, 4}Output: 3Explanation: Given arra
6 min read
Number of distinct permutation a String can have
We are given a string having only lowercase alphabets. The task is to find out total number of distinct permutation can be generated by that string. Examples: Input : aab Output : 3 Different permutations are "aab", "aba" and "baa". Input : ybghjhbuytb Output : 1663200 A simple solution is to find a
6 min read
Inverse Permutation
Given an array of size n of integers in range from 1 to n, we need to find the inverse permutation of that array. An inverse permutation is a permutation which you will get by inserting position of an element at the position specified by the element value in the array. For better understanding, cons
9 min read