N 个元素可以形成两个不同集合的方式计数，每个集合包含 N/2 个元素

给定一个数字N ，表示元素的数量并且等于2K ，任务是找到这些元素可以形成 2 个集合的方式的数量，每个集合包含K个元素。

例子：

Input: N = 4
Output: 3
Explanation: The 3 sets consisting of 2 (= N/2) elements are:
             [1, 2], [3, 4]
             [1, 3], [2, 4]
             [1, 4], [2, 3]           

Input: N = 20
Output: 12164510040883200

方法：要注意的是，必须应用组合的概念才能为每个集合选择元素。
已知从总共n 个事物中选择r个事物的方法数由下式给出：

^{nC_{r = n!/(n-r)!*r!}} 
 

现在，可以修改上面的公式来解决给定的问题：

• 在这里，必须从N个元素中选择N/2 个元素来形成每个集合。因此， r = N/2 。
• 需要注意的是，同一元素不能同时存在于两个集合中。所以， ⁿ C _r的公式 必须除以 2。
• 此外，每个集合中存在的元素可以排列成（N / 2-1）！方法。由于有两组，公式将乘以该因子两次。

得到的修正公式由下式给出：

Number of ways = ((N! / (N – r)!*r!) / 2) * (N / 2 – 1)!*(N / 2 – 1)! where r = N / 2

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the factorial
// of values
long long int fact(long long int N)
{
    // Factorial of 0 is 1
    if (N == 0) {
        return 1;
    }
    else {
 
        // Recursive function call
        return N * fact(N - 1);
    }
}
 
// Driver Code
int main()
{
 
    // Given input
    int N = 20;
 
    // Function Call
    cout << (fact(N) / (fact(N / 2)
                        * fact(N - N / 2)))
                / 2
                * fact(N / 2 - 1)
                * fact(N / 2 - 1);
 
    return 0;
}

Java

// Java code for the above approach
import java.io.*;
class GFG
{
   
    // Function to find the factorial
    // of values
    static long fact(long N)
    {
       
        // Factorial of 0 is 1
        if (N == 0) {
            return 1;
        }
        else {
 
            // Recursive function call
            return N * fact(N - 1);
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given input
        int N = 20;
 
        // Function Call
        System.out.println(
            (fact(N) / (fact(N / 2) * fact(N - N / 2))) / 2
            * fact(N / 2 - 1) * fact(N / 2 - 1));
    }
}
 
// This code is contributed by Potta Lokesh

Python3

# python program for the above approach
 
# Function to find the factorial
# of values
def fact(N):
 
    # Factorial of 0 is 1
    if (N == 0):
        return 1
 
    else:
 
        # Recursive function call
        return N * fact(N - 1)
 
# Driver Code
if __name__ == "__main__":
 
    # Given input
    N = 20
 
    # Function Call
    print(int((fact(N) / (fact(N / 2) * fact(N - N / 2))) /
              2 * fact(N / 2 - 1) * fact(N / 2 - 1)))
 
# This code is contributed by rakeshsahni

C#

// C# code for the above approach
using System;
public class GFG
{
   
    // Function to find the factorial
    // of values
    static long fact(long N)
    {
       
        // Factorial of 0 is 1
        if (N == 0) {
            return 1;
        }
        else {
 
            // Recursive function call
            return N * fact(N - 1);
        }
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        // Given input
        int N = 20;
 
        // Function Call
        Console.WriteLine(
            (fact(N) / (fact(N / 2) * fact(N - N / 2))) / 2
            * fact(N / 2 - 1) * fact(N / 2 - 1));
    }
}
 
// This code is contributed AnkThon

Javascript

// Javascript program for the above approach
 
// Function to find the factorial
// of values
function fact(N)
{
 
    // Factorial of 0 is 1
    if (N == 0) {
        return 1;
    }
    else {
 
        // Recursive function call
        return N * fact(N - 1);
    }
}
 
// Driver Code
 
// Given input
let N = 20;
 
// Function Call
document.write((fact(N) / (fact(N / 2)
                * fact(N - N / 2)))
            / 2
            * fact(N / 2 - 1)
            * fact(N / 2 - 1));
             
// This code is contributed by Samim Hossain Mondal.

输出

12164510040883200

时间复杂度： O(N)
辅助空间： O(N)