Rencontres Number in Java

Two numbers are given to us., The first number is a whole number, denoted by n, and the second number is a non-negative number, which is less than or equal to n, represented by k. The task is to find out the total number of disarrangements for the given numbers n and k, such that only k elements should be there at their original positions. In other words, we have to find the total number of derangements. The total

Example 1:

Input: int n = 3, int k = 0

Output: 2

Explanation: The value of k is 0. It means no number needs to be in its original position. The disarrangements are {2, 3, 1} and {3, 1, 2}.

Example 2:

Input: int n = 3, k = 1

Output: 3

Explanation: The value of k is 1. Therefore, there should be only one number that should be in its original position. Thus, the disarrangements we get are
are {2, 1, 3}, {1, 3, 2}, and {3, 2, 1}.

Approach: Using Recurrence Relation
In mathematics, the Rencontres numbers D(n, k) gives the total number of partial derangements. The recurrence relation is given as:

D(n, k) = ⁿC_k x D(n - k, 0) and for k = 0, the relation can be given as:

D(n, 0) = (n - 1) * (D(n - 1, 0) + D(n - 2, 0))
and for the base case, we have:

D(0, 0) = 1, D(0, 1) = 0, and D(1, 0) = 0

Thus,
For n = 1, k = 1, we get
D(1, 1) = ¹C₁ x D(1 - 1, 0) = 1 x D(0, 0) = 1 x 1 = 1

For n = 2, k = 1, we get
D(2, 1) = ²C₁ x D(2 - 1, 0) = 2 x D(1, 0) = 2 x 0 = 0

For n = 3, k = 1, we get
D(3, 1) = ³C₁ x D(3 - 1, 0) = 3 x D(2, 0)

Now, we have to find the value of D(2, 0), which can be found using the other recurrence relation.
D(n, 0) = (n - 1) x (D(n - 1, 0) + D(n - 2, 0))

D(2, 0) = (2 - 1) x (D(2 - 1, 0) + D(2 - 2, 0)) = 1 x (D(1, 0) + D (0, 0)) = 1 x (0 + 1) = 1 x 1 = 1

Hence, we get

D(3, 1) = 3 x D(2, 0) = 3 x 1 = 3

Now, let us implement the above relation.

FileName: RencontresNumberRec.java

public class RencontresNumberRec
{
// A method that returns the value of C(n, k)
static int binomialCoefficient(int n, int k)
{
	
	// handling the base condition
	if (n == k)
	{
		return 1;
	}
	// handling the base condition	
	if(k == 0)
	{
	    return 1;
	}

	// using the recurrence relation
	return binomialCoefficient(n - 1, k - 1) + binomialCoefficient(n - 1, k);
}
// a method that returns the value of Rencontres number D(n, m)
public int findRencontresNum(int n, int m)
{	
	// handling the base condition
	if (n == 0 && m == 0)
	{
		return 1;
	}
	// handling the base condition
	if (n == 1 && m == 0)
	{
		return 0;
	}
	// handling the base condition
	if (m == 0)
	{
		return (n - 1) * (findRencontresNum(n - 1, m) + findRencontresNum(n - 2, m));
	}
	return binomialCoefficient(n, m) * findRencontresNum(n - m, 0);
}

// main method
public static void main(String[] args)
{
    // instantiating the class RencontresNumberRec
    RencontresNumberRec obj = new RencontresNumberRec();
           // first input
	int n = 7;
	int k = 2;
	int ans = obj.findRencontresNum(n, k);
	System.out.println("For the value of n = " + n + " and k = " + k + ", the total number of derangements are: " + ans);
	// second input
	n = 3;
	k = 1;
	ans = obj.findRencontresNum(n, k);
	System.out.println("For the value of n = " + n + " and k = " + k + ", the total number of derangements are: " + ans);
	// third input
	n = 1;
	k = 1;
	ans = obj.findRencontresNum(n, k);
	System.out.println("For the value of n = " + n + " and k = " + k + ", the total number of derangements are: " + ans);
}
}

Output:

For the value of n = 7 and k = 2, the total number of derangements are: 924
For the value of n = 3 and k = 1, the total number of derangements are: 3
For the value of n = 1 and k = 1, the total number of derangements are: 1

Complexity Analysis: The time complexity of the program is O(n x k), where n and k represent the input integers. The space complexity of the program is also O(n x k), because of the recursive stack.

Approach: Using Dynamic Programming

In this approach, we will first split the problems into smaller ones and then solve those smaller problems. We will store the solutions in a 2-D array and then use it to find the solution to the given problem.

FileName: RencontresNumDP.java

public class RencontresNumDP
{
int MAXIMUM = 100;
// Filling up the table dp[n + 1][k + 1], such that C[i][j]
// represents a table of binomial coefficient
// iCj
public static void binomialCoeff(int dp[][], int n, int k)
{
// Calculating the value of the Binomial Coefficient
// in the bottom-up manner
for (int j = 0; j <= n; j++) {
	for (int l = 0; l <= Math.min(j, k); l++)
	{
		// handling the base Cases
		if (l == 0 || l == j)
		{
			dp[j][l] = 1;
		}
		// Computing the value using the values
		// that have been stored earlier
		else
		{
			dp[j][l] = dp[j - 1][l - 1] + dp[j - 1][l];
		}
	}
}
}
// a method that computes the value of D(n, k)
public int findRenNum(int recNum[][], int n, int k)
{
int dp[][] = new int[n + 1][k + 1];
for (int j = 0; j <= n; j++) 
{
for (int l = 0; l <= k; l++) 
{
if (l <= j) 
{
	// handling the base case
	if (j == 0 && l == 0)
	{
		dp[j][l] = 1;
	}
	// handling the base case
	else if (j == 1 && l == 0)
	{
		dp[j][l] = 0;
	}
	else if (l == 0)
	{
		dp[j][l] = (j - 1) * (dp[j - 1][0] + dp[j - 2][0]);
	}
	else
	{
		dp[j][l] = recNum[j][l] * dp[j - l][0];
	}
}
}
}
return dp[n][k];
}
// main method
public static void main(String[] args)
{
    // instantiating the class RencontresNumDP
    RencontresNumDP obj = new RencontresNumDP();
    
    // first input
	int n = 7;
	int k = 2;
	int C[][] = new int[n + 1][k + 1];
	binomialCoeff(C, n, k);
	int ans = obj.findRenNum(C, n, k);
	System.out.println("For the value of n = " + n + " and k = " + k + ", the total number of derangements are: " + ans);	
	// second input
	n = 3;
	k = 1;
	int C1[][] = new int[n + 1][k + 1];
	binomialCoeff(C1, n, k);
	ans = obj.findRenNum(C1, n, k);
	System.out.println("For the value of n = " + n + " and k = " + k + ", the total number of derangements are: " + ans);	
	// third input
	n = 1;
	k = 1;
	int C2[][] = new int[n + 1][k + 1];
	binomialCoeff(C2, n, k);
	ans = obj.findRenNum(C2, n, k);
	System.out.println("For the value of n = " + n + " and k = " + k + ", the total number of derangements are: " + ans);
}
}

Output:

For the value of n = 7 and k = 2, the total number of derangements are: 924
For the value of n = 3 and k = 1, the total number of derangements are: 3
For the value of n = 1 and k = 1, the total number of derangements are: 1

Complexity Analysis: The time, as well as the space complexity of the program, is the same as the previous program.

Next TopicSkewed Binary Tree in Java

← prev next →