[GeeksForGeeks] 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.

 The problem itself is pretty straightforward with the following optimal substructure:

f(n) = f(n - 1) + (n - 1) * f(n - 2);

To make it more challenging, write a method that generates all possible pairing ways and save them in a list.

This is a dfs + backtracking question.

Provided the optimal substructure, we know that for a given person, either he is single or he pairs with one other person.

If he is single, we simply reduce the problem to be one fewer person smaller;

If he is paired with another person, we pick one from all the available persons pool.

To avoid duplicated answers, we only pick person with a bigger number as the pair of the current person.   

We also need a global flag for each person to indicate if a person has been picked or not. This is needed because when picking 

a pair, there will be persons left in between these 2 picked persons and these left persons have not been picked yet. The remaining 

subproblem should include these unpicked persons. By only advancing the current index does not address this issue. 

import java.util.List;
import java.util.ArrayList;

public class FriendsPairing {
    //f(n) = f(n - 1) + (n - 1) * f(n - 2);
    //Recursive solution
    public static int pairingWaysRecursion(int n) {
        if(n <= 1) {
            return 1;
        }
        return pairingWaysRecursion(n - 1) + (n - 1) * pairingWaysRecursion(n - 2);
    }
    //Dynamic Programming 
    public static int pairingWaysDp(int n) {
        int[] T = new int[n + 1];
        T[0] = 1;
        T[1] = 1;
        for(int i = 2; i <= n; i++) {
            T[i] = T[i - 1] + (i - 1) * T[i - 2];
        }
        return T[n];
    }
    //Dfs + backtracking to get all pairing ways
    public static List<List<List<Integer>>> getAllPairingWays(int n) {
        boolean[] available = new boolean[n + 1];
        for(int i = 1; i <= n; i++) {
            available[i] = true;
        }
        List<List<List<Integer>>> ways = new ArrayList<>();
        getAllWaysDfs(ways, new ArrayList<>(), available, n, 1, 0);
        return ways;
    }
    private static void getAllWaysDfs(List<List<List<Integer>>> ways, 
                                List<List<Integer>> way,
                                boolean[] available, int n, int currIdx, int addedCount) {
        if(addedCount == n) {
37             ways.add(new ArrayList<List<Integer>>(way));
            return;
        }
        for(int i = currIdx; i <= n; i++) {
            if(available[i]) {
42                 ArrayList<Integer> group1 = new ArrayList<Integer>();
                group1.add(i);
                way.add(group1);
                available[i] = false;
                getAllWaysDfs(ways, way, available, n, i + 1, addedCount + 1);            
                way.remove(way.size() - 1);    
                
                int j = i + 1;
                for(; j <= n; j++) {
                    if(available[j]) {
52                         ArrayList<Integer> group2 = new ArrayList<Integer>();
                        group2.add(i);
                        group2.add(j);
                        way.add(group2);
                        available[j] = false;
                        getAllWaysDfs(ways, way, available, n, i + 1, addedCount + 2);        
                        way.remove(way.size() - 1);
                        available[j] = true;
                    }
                }
                available[i] = true;
            }
        }
    }
    public static void main(String[] args) {
        System.out.println(pairingWaysDp(3));
        System.out.println(pairingWaysDp(6));
        List<List<List<Integer>>> ways = getAllPairingWays(3);
        for(int i = 0; i < ways.size(); i++) {
            for(int j = 0; j < ways.get(i).size(); j++) {
                for(int k = 0; k < ways.get(i).get(j).size(); k++) {
                    System.out.print(ways.get(i).get(j).get(k) + ",");
                }
                System.out.print("  ");
            }
            System.out.println();
        }
    }
}

Related Problems 

Permutations 

Permutations II