Find the number of good permutations

Given two integers N and K. The task is to find the number of good permutations of first N natural numbers. A permutation is called good if there exist at least N – K indices i (1 ≤ i ≤ N) such that P_i = i.

Examples:

Input: N = 4, K = 1
Output: 1
{1, 2, 3, 4} is the only possible good permutation.

Input: N = 5, K = 2
Output: 11

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Let’s iterate on m which is the number of indices such that P_i not equals to i. Obviously, 0 ≤ m ≤ k.
In order to count the number of permutations with fixed m, we need to choose the indices that have the property P_i not equals to i – there are ⁿC_m ways to do this then we need to construct a permutation Q for chosen indices such that for every chosen index Q_i not equals to i. Permutations with this property are called derangements and the number of derangements of fixed size can be calculated using exhaustive search since m ≤ 4.

Below is the implementation of the above approach:

C++

// C++ implementation of the approach 
#include <bits/stdc++.h> 
using namespace std; 
  
// Function to return the count of good permutations 
int Permutations(int n, int k) 
{ 
    // For m = 0, ans is 1 
    int ans = 1; 
  
    // If k is greater than 1 
    if (k >= 2) 
        ans += (n) * (n - 1) / 2; 
  
    // If k is greater than 2 
    if (k >= 3) 
        ans += (n) * (n - 1) * (n - 2) * 2 / 6; 
  
    // If k is greater than 3 
    if (k >= 4) 
        ans += (n) * (n - 1) * (n - 2) * (n - 3) * 9 / 24; 
  
    return ans; 
} 
  
// Driver code 
int main() 
{ 
    int n = 5, k = 2; 
    cout << Permutations(n, k); 
  
    return 0; 
} 

Java

// Java implementation of the approach 
class GFG  
{ 
  
// Function to return the count of good permutations 
static int Permutations(int n, int k) 
{ 
    // For m = 0, ans is 1 
    int ans = 1; 
  
    // If k is greater than 1 
    if (k >= 2) 
        ans += (n) * (n - 1) / 2; 
  
    // If k is greater than 2 
    if (k >= 3) 
        ans += (n) * (n - 1) * (n - 2) * 2 / 6; 
  
    // If k is greater than 3 
    if (k >= 4) 
        ans += (n) * (n - 1) * (n - 2) * (n - 3) * 9 / 24; 
  
    return ans; 
} 
  
// Driver code 
public static void main(String[] args)  
{ 
    int n = 5, k = 2; 
    System.out.println(Permutations(n, k)); 
} 
} 
  
// This code contributed by Rajput-Ji 

Python3

# Python3 implementation of the approach  
  
# Function to return the count  
# of good permutations  
def Permutations(n, k):  
  
    # For m = 0, ans is 1  
    ans = 1
  
    # If k is greater than 1  
    if k >= 2:  
        ans += (n) * (n - 1) // 2
  
    # If k is greater than 2  
    if k >= 3: 
        ans += ((n) * (n - 1) * 
                (n - 2) * 2 // 6) 
  
    # If k is greater than 3  
    if k >= 4: 
        ans += ((n) * (n - 1) * (n - 2) *
                      (n - 3) * 9 // 24) 
  
    return ans  
  
# Driver code  
if __name__ == "__main__": 
  
    n, k = 5, 2
    print(Permutations(n, k))  
      
# This code is contributed 
# by Rituraj Jain 

C#

// C# implementation of the above approach. 
using System; 
  
class GFG  
{ 
  
// Function to return the count of good permutations 
static int Permutations(int n, int k) 
{ 
    // For m = 0, ans is 1 
    int ans = 1; 
  
    // If k is greater than 1 
    if (k >= 2) 
        ans += (n) * (n - 1) / 2; 
  
    // If k is greater than 2 
    if (k >= 3) 
        ans += (n) * (n - 1) * (n - 2) * 2 / 6; 
  
    // If k is greater than 3 
    if (k >= 4) 
        ans += (n) * (n - 1) * (n - 2) * (n - 3) * 9 / 24; 
  
    return ans; 
} 
  
// Driver code 
public static void Main()  
{ 
    int n = 5, k = 2; 
    Console.WriteLine(Permutations(n, k)); 
} 
} 
  
/* This code contributed by PrinciRaj1992 */