 Open in App
Not now

# Count Derangements (Permutation such that no element appears in its original position)

• Difficulty Level : Medium
• Last Updated : 20 Jul, 2022

A Derangement is a permutation of n elements, such that no element appears in its original position. For example, a derangement of {0, 1, 2, 3} is {2, 3, 1, 0}.
Given a number n, find the total number of Derangements of a set of n elements.

Examples :

```Input: n = 2
Output: 1
For two elements say {0, 1}, there is only one
possible derangement {1, 0}

Input: n = 3
Output: 2
For three elements say {0, 1, 2}, there are two
possible derangements {2, 0, 1} and {1, 2, 0}

Input: n = 4
Output: 9
For four elements say {0, 1, 2, 3}, there are 9
possible derangements {1, 0, 3, 2} {1, 2, 3, 0}
{1, 3, 0, 2}, {2, 3, 0, 1}, {2, 0, 3, 1}, {2, 3,
1, 0}, {3, 0, 1, 2}, {3, 2, 0, 1} and {3, 2, 1, 0}```

Let countDer(n) be count of derangements for n elements. Below is the recursive relation to it.

`countDer(n) = (n - 1) * [countDer(n - 1) + countDer(n - 2)]`

How does above recursive relation work?

There are n – 1 way for element 0 (this explains multiplication with n – 1).
Let 0 be placed at index i. There are now two possibilities, depending on whether or not element i is placed at 0 in return.

1. i is placed at 0: This case is equivalent to solving the problem for n-2 elements as two elements have just swapped their positions.
2. i is not placed at 0: This case is equivalent to solving the problem for n-1 elements as now there are n-1 elements, n-1 positions and every element has n-2 choices

Below is the simple solution based on the above recursive formula:

## C++

 `// A Naive Recursive C++ program ` `// to count derangements` `#include ` `using` `namespace` `std;`   `int` `countDer(``int` `n)` `{` `  ``// Base cases` `  ``if` `(n == 1) ``return` `0;` `  ``if` `(n == 2) ``return` `1;`   `  ``// countDer(n) = (n-1)[countDer(n-1) + der(n-2)]` `  ``return` `(n - 1) * (countDer(n - 1) + countDer(n - 2));` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 4;` `    ``cout << ``"Count of Derangements is "` `         ``<< countDer(n);` `    ``return` `0;` `}`

## Java

 `// A Naive Recursive java ` `// program to count derangements` `import` `java.io.*;`   `class` `GFG ` `{` `    `  `    ``// Function to count` `    ``// derangements` `    ``static` `int` `countDer(``int` `n)` `    ``{` `        ``// Base cases` `        ``if` `(n == ``1``) ``return` `0``;` `        ``if` `(n == ``2``) ``return` `1``;` `        `  `        ``// countDer(n) = (n-1)[countDer(n-1) + der(n-2)]` `        ``return` `(n - ``1``) * (countDer(n - ``1``) + ` `                          ``countDer(n - ``2``));` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `n = ``4``;` `        ``System.out.println( ``"Count of Derangements is "` `                             ``+countDer(n));`   `    ``}` `}`   `// This code is contributed by vt_m`

## Python3

 `# A Naive Recursive Python3 ` `# program to count derangements`   `def` `countDer(n):` `    `  `    ``# Base cases` `    ``if` `(n ``=``=` `1``): ``return` `0` `    ``if` `(n ``=``=` `2``): ``return` `1` `    `  `    ``# countDer(n) = (n-1)[countDer(n-1) + der(n-2)]` `    ``return` `(n ``-` `1``) ``*` `(countDer(n ``-` `1``) ``+` `                      ``countDer(n ``-` `2``))`   `# Driver Code` `n ``=` `4` `print``(``"Count of Derangements is "``, countDer(n))`     `# This code is contributed by Azkia Anam.`

## C#

 `// A Naive Recursive C#` `// program to count derangements` `using` `System;`   `class` `GFG ` `{` `    `  `    ``// Function to count` `    ``// derangements` `    ``static` `int` `countDer(``int` `n)` `    ``{` `        ``// Base cases` `        ``if` `(n == 1) ``return` `0;` `        ``if` `(n == 2) ``return` `1;` `        `  `        ``// countDer(n) = (n-1)[countDer(n-1) + der(n-2)]` `        ``return` `(n - 1) * (countDer(n - 1) + ` `                          ``countDer(n - 2));` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `n = 4;` `        ``Console.Write( ``"Count of Derangements is "` `+` `                        ``countDer(n));`   `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output

`Count of Derangements is 9`

Time Complexity: O(2^n) since T(n) = T(n-1) + T(n-2) which is exponential.

Auxiliary Space: O(h) where h= log n is the maximum height of the tree.

We can observe that this implementation does repetitive work. For example, see recursion tree for countDer(5), countDer(3) is being evaluated twice.

```cdr() ==> countDer()

cdr(5)
/         \
cdr(4)          cdr(3)
/      \         /     \
cdr(3)     cdr(2)  cdr(2)   cdr(1)```

An Efficient Solution is to use Dynamic Programming to store results of subproblems in an array and build the array in bottom-up manner.

## C++

 `// A Dynamic programming based C++ ` `// program to count derangements` `#include ` `using` `namespace` `std;`   `int` `countDer(``int` `n)` `{` `    ``// Create an array to store ` `    ``// counts for subproblems` `    ``int` `der[n + 1] = {0};`   `    ``// Base cases` `    ``der = 0;` `    ``der = 1;`   `    ``// Fill der[0..n] in bottom up manner ` `    ``// using above recursive formula` `    ``for` `(``int` `i = 3; i <= n; ++i)` `        ``der[i] = (i - 1) * (der[i - 1] + ` `                            ``der[i - 2]);`   `    ``// Return result for n` `    ``return` `der[n];` `}`   `// Driver code` `int` `main()` `{` `    ``int` `n = 4;` `    ``cout << ``"Count of Derangements is "` `         ``<< countDer(n);` `    ``return` `0;` `}`

## Java

 `// A Dynamic programming based ` `// java program to count derangements` `import` `java.io.*;`   `class` `GFG ` `{` `    `  `    ``// Function to count` `    ``// derangements ` `    ``static` `int` `countDer(``int` `n)` `    ``{` `        ``// Create an array to store` `        ``// counts for subproblems` `        ``int` `der[] = ``new` `int``[n + ``1``];` `    `  `        ``// Base cases` `        ``der[``1``] = ``0``;` `        ``der[``2``] = ``1``;` `    `  `        ``// Fill der[0..n] in bottom up ` `        ``// manner using above recursive` `        ``// formula` `        ``for` `(``int` `i = ``3``; i <= n; ++i)` `            ``der[i] = (i - ``1``) * (der[i - ``1``] + ` `                                ``der[i - ``2``]);` `    `  `        ``// Return result for n` `        ``return` `der[n];` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``int` `n = ``4``;` `        ``System.out.println(``"Count of Derangements is "` `+ ` `                            ``countDer(n));` `    `  `    ``}` `}`   `// This code is contributed by vt_m`

## Python3

 `# A Dynamic programming based Python3` `# program to count derangements`   `def` `countDer(n):` `    `  `    ``# Create an array to store` `    ``# counts for subproblems` `    ``der ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]` `    `  `    ``# Base cases` `    ``der[``1``] ``=` `0` `    ``der[``2``] ``=` `1` `    `  `    ``# Fill der[0..n] in bottom up manner ` `    ``# using above recursive formula` `    ``for` `i ``in` `range``(``3``, n ``+` `1``):` `        ``der[i] ``=` `(i ``-` `1``) ``*` `(der[i ``-` `1``] ``+` `                            ``der[i ``-` `2``])` `        `  `    ``# Return result for n` `    ``return` `der[n]`   `# Driver Code` `n ``=` `4` `print``(``"Count of Derangements is "``, countDer(n))`   `# This code is contributed by Azkia Anam.`

## C#

 `// A Dynamic programming based ` `// C# program to count derangements` `using` `System;`   `class` `GFG ` `{` `    `  `    ``// Function to count` `    ``// derangements ` `    ``static` `int` `countDer(``int` `n)` `    ``{` `        ``// Create an array to store` `        ``// counts for subproblems` `        ``int` `[]der = ``new` `int``[n + 1];` `    `  `        ``// Base cases` `        ``der = 0;` `        ``der = 1;` `    `  `        ``// Fill der[0..n] in bottom up ` `        ``// manner using above recursive` `        ``// formula` `        ``for` `(``int` `i = 3; i <= n; ++i)` `            ``der[i] = (i - 1) * (der[i - 1] + ` `                                ``der[i - 2]);` `    `  `        ``// Return result for n` `        ``return` `der[n];` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main () ` `    ``{` `        ``int` `n = 4;` `        ``Console.Write(``"Count of Derangements is "` `+ ` `                       ``countDer(n));` `    `  `    ``}` `}`   `// This code is contributed by nitin mittal`

## PHP

 ``

## Javascript

 ``

Output

`Count of Derangements is 9`

Time Complexity : O(n)
Auxiliary Space : O(n)
Thanks to Utkarsh Trivedi for suggesting the above solution.

A More Efficient Solution Without using Extra Space.

As we only need to remember only two previous values So, instead of Storing the values in an array two variables can be used to just store the required previous only.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above` `// approach`   `#include ` `using` `namespace` `std;`   `int` `countDer(``int` `n)` `{`   `    ``// base case` `    ``if` `(n == 1 or n == 2) {` `        ``return` `n - 1;` `    ``}`   `    ``// Variable for just storing` `    ``// previous values` `    ``int` `a = 0;` `    ``int` `b = 1;`   `    ``// using above recursive formula` `    ``for` `(``int` `i = 3; i <= n; ++i) {` `        ``int` `cur = (i - 1) * (a + b);` `        ``a = b;` `        ``b = cur;` `    ``}`   `    ``// Return result for n` `    ``return` `b;` `}`   `// Driver Code` `int` `main()` `{`   `    ``cout << ``"Count of Derangements is "` `<< countDer(4);` `    ``return` `0;` `}`   ` ``// Code contributed by skagnihotri`

## Java

 `// Java implementation of the ` `// above approach`   `import` `java.io.*;`   `class` `GFG {` `  `  `    ``// Function to count derangements  ` `    ``static` `int` `countDer(``int` `n) { ` `        ``// Base case` `          ``if``(n == ``1` `|| n == ``2``) {` `            ``return` `n-``1``;` `        ``}` `      `  `        ``// Variable for storing prev values` `        ``int` `a = ``0``;` `          ``int` `b = ``1``;` `      `  `        ``// manner using above recursive formula ` `        ``for` `(``int` `i = ``3``; i <= n; ++i) {` `            ``int` `cur = (i-``1``)*(a+b);` `            ``a = b;` `              ``b = cur;` `        ``}` `            `  `        ``// Return result for n ` `        ``return` `b; ` `    ``} ` `      `  `    ``// Driver Code ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `n = ``4``; ` `        ``System.out.println(``"Count of Derangements is "` `+  ` `                            ``countDer(n)); ` `      `  `    ``}` `  `  `  ``// Code contributed by skagnihotri` `}`

## Python3

 `# Python program to count derangements ` `  `  `def` `countDer(n):` `      `  `    ``# Base Case` `    ``if` `n ``=``=` `1` `or` `n ``=``=` `2``:` `      ``return` `n``-``1``;` `        `  `    ``# Variables for storing previous values` `    ``a ``=` `0` `    ``b ``=` `1` `    `  `    ``# using above recursive formula ` `    ``for` `i ``in` `range``(``3``, n ``+` `1``): ` `        ``cur ``=` `(i``-``1``)``*``(a``+``b)` `        ``a ``=` `b` `        ``b ``=` `cur` `        `  `    ``# Return result for n ` `    ``return` `b ` `  `  `# Driver Code ` `n ``=` `4` `print``(``"Count of Derangements is "``, countDer(n)) ` `# Code contributed by skagnihotri`

## C#

 `// C# implementation of the above` `// approach` `using` `System;`   `class` `GFG{` `    `  `// Function to count` `// derangements ` `static` `int` `countDer(``int` `n)` `{` `    `  `    ``// Base case` `    ``if` `(n == 1 || n == 2) ` `    ``{` `        ``return` `n - 1;` `    ``}`   `    ``// Variable for just storing` `    ``// previous values` `    ``int` `a = 0;` `    ``int` `b = 1;`   `    ``// Using above recursive formula` `    ``for``(``int` `i = 3; i <= n; ++i)` `    ``{` `        ``int` `cur = (i - 1) * (a + b);` `        ``a = b;` `        ``b = cur;` `    ``}`   `    ``// Return result for n` `    ``return` `b;` `}`   `// Driver code` `public` `static` `void` `Main() ` `{` `    ``Console.Write(``"Count of Derangements is "` `+ ` `                   ``countDer(4));` `}` `}`   `// This code is contributed by koulick_sadhu`

## Javascript

 ``

Output

`Count of Derangements is 9`

Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.

Thanks to Shubham Kumar for suggesting the above solution.

References:
https://en.wikipedia.org/wiki/Derangement