Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Find the Number of permutation with K inversions using C++
In an array, A pair a[i], a[j] is known as an inversion if a[i] > a[j] and i < j. We have two numbers N and k, and need to figure out how many possible permutations of the first N numbers end in a perfect K inversion. So here is the example −
Input: N = 4, K = 1 Output: 3 Explanation: Permutation of the first N numbers in total : 1234, 1243, 1324 and 2134. With 1 inversion we have 1243, 1324 and 2134. Input : N = 3, K = 2 Output : 3 Explanation: Permutation of the first N numbers in total : 123, 132, 213, 231, 312, and 321 with 2 inversions we have 231, 312 and 321.
Approach to Find Solution
We can apply the Brute force approach, which is first finding all the permutations of first N numbers and then checking all the inversions whether it is equal to K or not. If yes, then incrementing the resulting counter.
Efficient Approach
In this approach, we have N digits of first N natural numbers. All permutations of that number are calculated somewhere else from which we are looking for K permutations. To find it, We will be inserting the next number Nth(largest) in all permutations and looking for those numbers whose inversion count is equal to K after adding this number should be counted in our result. Taking such permutations of (N – 1) numbers that do not have (K – 3) inversion, we will shift the new number at the 3rd index from last. The number of inversions will be K, and find_permutations(N-1, K-3) will be our answer. The same logic can be used for other inversions, and we'll arrive at the above recursion as the final answer.
Input
#include <bits/stdc++.h>
using namespace std;
const int X = 100;
int a = 0;
int arr[X][X];
// recursive function
int find_permutations (int N_numbers, int K_inversion){
if (N_numbers == 0){
return 0; // return 0 when N becomes 0
}
if (K_inversion == 0)
return 1; // return 1 when K becomes 1
if (arr[N_numbers][K_inversion] != 0)
return arr[N_numbers][K_inversion];
int result = 0;
for (int i = 0; i <= K_inversion; i++){
if (i <= N_numbers - 1)
result += find_permutations (N_numbers - 1, K_inversion - i);
}
arr[N_numbers][K_inversion] = result;
return result;
}
// main function
int main (){
int N, K;
cin >> N; // taking input from user
cin >> K;
cout << find_permutations (N, K);
return 0;
}Output
0
Input − N = 4, K = 3
Output − 6
Conclusion
In this article, we solve a problem to find the Number of permutations with K inversions from O(n * k) time complexity. We also learned the C++ program for this problem and the complete approach ( Normal and efficient ) by which we solved this problem. We can write the same program in other languages such as C, java, python, and other languages. Hope you find this article helpful.
245 Views
