# Friends Pairing Problem

Given n friends, each one can remain single or can be paired up with some other friend. Each friend can be paired only once. Find out the total number of ways in which friends can remain single or can be paired up.

Examples :

```Input  : n = 3
Output : 4

Explanation
{1}, {2}, {3} : all single
{1}, {2, 3} : 2 and 3 paired but 1 is single.
{1, 2}, {3} : 1 and 2 are paired but 3 is single.
{1, 3}, {2} : 1 and 3 are paired but 2 is single.
Note that {1, 2} and {2, 1} are considered same.
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

```f(n) = ways n people can remain single
or pair up.

For n-th person there are two choices:
1) n-th person remains single, we recur
for f(n - 1)
2) n-th person pairs up with any of the
remaining n - 1 persons. We get (n - 1) * f(n - 2)

Therefore we can recursively write f(n) as:
f(n) = f(n - 1) + (n - 1) * f(n - 2)
```

Since above recursive formula has overlapping subproblems, we can solve it using Dynamic Programming.

## C++

 `// C++ program for solution of ` `// friends pairing problem ` `#include ` `using` `namespace` `std; ` ` `  `// Returns count of ways n people ` `// can remain single or paired up. ` `int` `countFriendsPairings(``int` `n) ` `{ ` `    ``int` `dp[n + 1]; ` ` `  `    ``// Filling dp[] in bottom-up manner using ` `    ``// recursive formula explained above. ` `    ``for` `(``int` `i = 0; i <= n; i++) { ` `        ``if` `(i <= 2) ` `            ``dp[i] = i; ` `        ``else` `            ``dp[i] = dp[i - 1] + (i - 1) * dp[i - 2]; ` `    ``} ` ` `  `    ``return` `dp[n]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 4; ` `    ``cout << countFriendsPairings(n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program for solution of ` `// friends pairing problem ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns count of ways n people ` `    ``// can remain single or paired up. ` `    ``static` `int` `countFriendsPairings(``int` `n) ` `    ``{ ` `        ``int` `dp[] = ``new` `int``[n + ``1``]; ` ` `  `        ``// Filling dp[] in bottom-up manner using ` `        ``// recursive formula explained above. ` `        ``for` `(``int` `i = ``0``; i <= n; i++) { ` `            ``if` `(i <= ``2``) ` `                ``dp[i] = i; ` `            ``else` `                ``dp[i] = dp[i - ``1``] + (i - ``1``) * dp[i - ``2``]; ` `        ``} ` ` `  `        ``return` `dp[n]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `n = ``4``; ` `        ``System.out.println(countFriendsPairings(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

## Python3

 `# Python program solution of ` `# friends pairing problem ` ` `  `# Returns count of ways ` `# n people can remain ` `# single or paired up. ` `def` `countFriendsPairings(n): ` ` `  `    ``dp ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)] ` ` `  `    ``# Filling dp[] in bottom-up manner using ` `    ``# recursive formula explained above. ` `    ``for` `i ``in` `range``(n ``+` `1``): ` ` `  `        ``if``(i <``=` `2``): ` `            ``dp[i] ``=` `i ` `        ``else``: ` `            ``dp[i] ``=` `dp[i ``-` `1``] ``+` `(i ``-` `1``) ``*` `dp[i ``-` `2``] ` ` `  `    ``return` `dp[n] ` ` `  `# Driver code ` `n ``=` `4` `print``(countFriendsPairings(n)) ` ` `  `# This code is contributed ` `# by Soumen Ghosh. `

## C#

 `// C# program solution for ` `// friends pairing problem ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Returns count of ways n people ` `    ``// can remain single or paired up. ` `    ``static` `int` `countFriendsPairings(``int` `n) ` `    ``{ ` `        ``int``[] dp = ``new` `int``[n + 1]; ` ` `  `        ``// Filling dp[] in bottom-up manner using ` `        ``// recursive formula explained above. ` `        ``for` `(``int` `i = 0; i <= n; i++) { ` `            ``if` `(i <= 2) ` `                ``dp[i] = i; ` `            ``else` `                ``dp[i] = dp[i - 1] + (i - 1) * dp[i - 2]; ` `        ``} ` ` `  `        ``return` `dp[n]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 4; ` `        ``Console.Write(countFriendsPairings(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal. `

## PHP

 ` `

Output :

```10
```

Time Complexity : O(n)
Auxiliary Space : O(n)

Another approach: (Using recursion)

## C++

 `// C++ program for solution of friends ` `// pairing problem Using Recursion ` `#include ` `using` `namespace` `std; ` ` `  `int` `dp; ` ` `  `// Returns count of ways n people ` `// can remain single or paired up. ` `int` `countFriendsPairings(``int` `n) ` `{ ` `    ``if` `(dp[n] != -1) ` `        ``return` `dp[n]; ` ` `  `    ``if` `(n > 2) ` `        ``return` `dp[n] = countFriendsPairings(n - 1) + (n - 1) * countFriendsPairings(n - 2); ` `    ``else` `        ``return` `dp[n] = n; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``memset``(dp, -1, ``sizeof``(dp)); ` `    ``int` `n = 4; ` `    ``cout << countFriendsPairings(n) << endl; ` `    ``// this code is contributed by Kushdeep Mittal ` `} `

## Java

 `// Java program for solution of friends ` `// pairing problem Using Recursion ` ` `  `class` `GFG { ` `    ``static` `int``[] dp = ``new` `int``[``1000``]; ` ` `  `    ``// Returns count of ways n people ` `    ``// can remain single or paired up. ` `    ``static` `int` `countFriendsPairings(``int` `n) ` `    ``{ ` `        ``if` `(dp[n] != -``1``) ` `            ``return` `dp[n]; ` ` `  `        ``if` `(n > ``2``) ` `            ``return` `dp[n] = countFriendsPairings(n - ``1``) + (n - ``1``) * countFriendsPairings(n - ``2``); ` `        ``else` `            ``return` `dp[n] = n; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < ``1000``; i++) ` `            ``dp[i] = -``1``; ` `        ``int` `n = ``4``; ` `        ``System.out.println(countFriendsPairings(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Ita_c. `

## Python3

 `# Python3 program for solution of friends  ` `# pairing problem Using Recursion  ` ` `  `# Returns count of ways n people  ` `# can remain single or paired up.  ` `def` `countFriendsPairings(n):  ` ` `  `    ``dp ``=` `[``-``1``] ``*` `100` `     `  `    ``if``(dp[n] !``=` `-``1``):  ` `        ``return` `dp[n]  ` ` `  `    ``if``(n > ``2``):  ` ` `  `        ``dp[n] ``=` `(countFriendsPairings(n ``-` `1``) ``+`  `                ``(n ``-` `1``) ``*` `countFriendsPairings(n ``-` `2``))  ` `        ``return` `dp[n] ` ` `  `    ``else``: ` `        ``dp[n] ``=` `n  ` `        ``return` `dp[n] ` `     `  `# Driver Code ` `n ``=` `4` `print``(countFriendsPairings(n)) ` ` `  `# This code contributed by PrinciRaj1992 `

## C#

 `// C# program for solution of friends ` `// pairing problem Using Recursion ` `using` `System; ` ` `  `class` `GFG { ` `    ``static` `int``[] dp = ``new` `int``; ` ` `  `    ``// Returns count of ways n people ` `    ``// can remain single or paired up. ` `    ``static` `int` `countFriendsPairings(``int` `n) ` `    ``{ ` `        ``if` `(dp[n] != -1) ` `            ``return` `dp[n]; ` ` `  `        ``if` `(n > 2) ` `            ``return` `dp[n] = countFriendsPairings(n - 1) + (n - 1) * countFriendsPairings(n - 2); ` `        ``else` `            ``return` `dp[n] = n; ` `    ``} ` ` `  `    ``// Driver code ` `    ``static` `void` `Main() ` `    ``{ ` `        ``for` `(``int` `i = 0; i < 1000; i++) ` `            ``dp[i] = -1; ` `        ``int` `n = 4; ` `        ``Console.Write(countFriendsPairings(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by DrRoot_ `

## PHP

 ` 2)  ` `    ``{ ` `        ``\$dp``[``\$n``] = countFriendsPairings(``\$n` `- 1) + (``\$n` `- 1) *  ` `                  ``countFriendsPairings(``\$n` `- 2);  ` `        ``return` `\$dp``[``\$n``]; ` `    ``} ` `    ``else` `    ``{ ` `        ``\$dp``[``\$n``] = ``\$n``;  ` `        ``return` `\$dp``[``\$n``]; ` `    ``} ` `}  ` `     `  `// Driver Code ` `\$n` `= 4;  ` `echo` `countFriendsPairings(``\$n``)  ` ` `  `// This code is contributed by Ryuga ` `?> `

Output :

```10
```

Time Complexity : O(n)
Auxiliary Space : O(n)

Since above formula is similar to fibonacci number, we can optimize the space with an iterative solution.

## C++

 `#include ` `using` `namespace` `std; ` ` `  `// Returns count of ways n people ` `// can remain single or paired up. ` `int` `countFriendsPairings(``int` `n) ` `{ ` `    ``int` `a = 1, b = 2, c = 0; ` `    ``if` `(n <= 2) { ` `        ``return` `n; ` `    ``} ` `    ``for` `(``int` `i = 3; i <= n; i++) { ` `        ``c = b + (i - 1) * a; ` `        ``a = b; ` `        ``b = c; ` `    ``} ` `    ``return` `c; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 4; ` `    ``cout << countFriendsPairings(n); ` `    ``return` `0; ` `} ` ` `  `// This code is contributed by mits `

## Java

 `class` `GFG { ` `    ``// Returns count of ways n people ` `    ``// can remain single or paired up. ` `    ``static` `int` `countFriendsPairings(``int` `n) ` `    ``{ ` `        ``int` `a = ``1``, b = ``2``, c = ``0``; ` `        ``if` `(n <= ``2``) { ` `            ``return` `n; ` `        ``} ` `        ``for` `(``int` `i = ``3``; i <= n; i++) { ` `            ``c = b + (i - ``1``) * a; ` `            ``a = b; ` `            ``b = c; ` `        ``} ` `        ``return` `c; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `n = ``4``; ` `        ``System.out.println(countFriendsPairings(n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Ravi Kasha. `

## Python3

 `# Returns count of ways n people ` `# can remain single or paired up. ` `def` `countFriendsPairings(n): ` `    ``a, b, c ``=` `1``, ``2``, ``0``; ` `    ``if` `(n <``=` `2``): ` `        ``return` `n; ` `    ``for` `i ``in` `range``(``3``, n ``+` `1``): ` `        ``c ``=` `b ``+` `(i ``-` `1``) ``*` `a; ` `        ``a ``=` `b; ` `        ``b ``=` `c; ` `    ``return` `c; ` ` `  `# Driver code ` `n ``=` `4``; ` `print``(countFriendsPairings(n)); ` ` `  `# This code contributed by Rajput-Ji `

## C#

 `using` `System; ` ` `  `class` `GFG { ` `    ``// Returns count of ways n people ` `    ``// can remain single or paired up. ` `    ``static` `int` `countFriendsPairings(``int` `n) ` `    ``{ ` `        ``int` `a = 1, b = 2, c = 0; ` `        ``if` `(n <= 2) { ` `            ``return` `n; ` `        ``} ` `        ``for` `(``int` `i = 3; i <= n; i++) { ` `            ``c = b + (i - 1) * a; ` `            ``a = b; ` `            ``b = c; ` `        ``} ` `        ``return` `c; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `n = 4; ` `        ``Console.WriteLine(countFriendsPairings(n)); ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## PHP

 ` `

Output :

```10
```

Time Complexity : O(n)
Auxiliary Space : O(1)

This article is contributed by Ekta Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.