使得两个子集包含相同数量元素的概率

给定一个包含N个元素的集合。如果选择了两个子集X和Y，则找到它们包含相同数量元素的概率。

例子：

Input: 4
Output: 35/128
Input: 2
Output: 3/8

方法：
让我们选择一个具有r个元素的子集X ，然后Y必须包含r个元素。一个子集可以具有最少0个元素和最多N个元素。

包含N个元素的集合的子集总数为$2^{n}$ ，同时选择X和Y的总可能方法为$2^{n} * 2^{n}$ = $4^{n}$ = $2^{2n}$ 。

设P =选择X和Y的总可能方式，以使它们都具有相同数量的元素。

那么P = $\sum_{r=0}^{n} ^nC_r * ^nC_r$ = $C_0^2+C_1^2+C_2^2+....+C_n^2$ = $^{2n}C_{n}$

因此所需的概率为$\frac{^{2n}C_{n}}{2^{2n}}$ 。

下面是上述方法的实现：

C++

// C++ implementation of
// the above approach
#include 
using namespace std;
  
// Returns value of Binomial
// Coefficient C(n, k)
int binomialCoeff(int n, int k)
{
    int res = 1;
  
    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;
  
    // Calculate value of
    for (int i = 0; i < k; ++i) {
        res *= (n - i);
        res /= (i + 1);
    }
  
    return res;
}
  
// Iterative Function to
// calculate (x^y) in O(log y)
int power(int x, unsigned int y)
{
    // Initialize result
    int res = 1;
  
    while (y > 0) {
  
        // If y is odd, multiply
        // x with result
        if (y & 1)
            res = res * x;
  
        // y must be even now
        // y = y/2
        y = y >> 1;
  
        // Change x to x^2
        x = x * x;
    }
    return res;
}
  
// Function to find probability
void FindProbability(int n)
{
  
    // Calculate total possible
    // ways and favourable ways.
    int up = binomialCoeff(2 * n, n);
    int down = power(2, 2 * n);
  
    // Divide by gcd such that
    // they become relatively coprime
    int g = __gcd(up, down);
  
    up /= g, down /= g;
  
    cout << up << "/" << down << endl;
}
  
// Driver code
int main()
{
  
    int N = 8;
  
    FindProbability(N);
  
    return 0;
}

Java

// Java implementation of 
// the above approach 
class GFG
{
      
    // Returns value of Binomial 
    // Coefficient C(n, k) 
    static int binomialCoeff(int n, int k) 
    { 
        int res = 1; 
      
        // Since C(n, k) = C(n, n-k) 
        if (k > n - k) 
            k = n - k; 
      
        // Calculate value of 
        for (int i = 0; i < k; ++i) 
        { 
            res *= (n - i); 
            res /= (i + 1); 
        } 
      
        return res; 
    } 
      
    // Iterative Function to 
    // calculate (x^y) in O(log y) 
    static int power(int x, int y) 
    { 
        // Initialize result 
        int res = 1; 
      
        while (y > 0) 
        { 
      
            // If y is odd, multiply 
            // x with result 
            if ((y & 1) == 1) 
                res = res * x; 
      
            // y must be even now 
            // y = y/2 
            y = y >> 1; 
      
            // Change x to x^2 
            x = x * x; 
        } 
        return res; 
    } 
      
    // Recursive function to return gcd of a and b 
    static int gcd(int a, int b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b); 
          
    } 
      
    // Function to find probability 
    static void FindProbability(int n) 
    { 
      
        // Calculate total possible 
        // ways and favourable ways. 
        int up = binomialCoeff(2 * n, n); 
        int down = power(2, 2 * n); 
      
        // Divide by gcd such that 
        // they become relatively coprime 
        int g = gcd(up, down); 
      
        up /= g;
        down /= g; 
      
        System.out.println(up + "/" + down); 
    } 
      
    // Driver code 
    public static void main (String[] args)
    { 
        int N = 8; 
      
        FindProbability(N); 
    } 
}
  
// This code is contributed by AnkitRai01

Python3

# Python3 implementation of 
# the above approach 
import math
  
# Returns value of Binomial 
# Coefficient C(n, k) 
def binomialCoeff(n, k):
  
    res = 1
  
    # Since C(n, k) = C(n, n-k) 
    if (k > n - k): 
        k = n - k 
  
    # Calculate value of 
    for i in range(0, k): 
        res = res * (n - i) 
        res = res // (i + 1)
  
    return res
  
# Iterative Function to 
# calculate (x^y) in O(log y) 
def power(x, y):
      
    # Initialize result 
    res = 1
  
    while (y > 0):
  
        # If y is odd, multiply 
        # x with result 
        if (y & 1):
            res = res * x
  
        # y must be even now 
        # y = y/2 
        y = y // 2
  
        # Change x to x^2 
        x = x * x
      
    return res 
  
# Function to find probability 
def FindProbability(n):
  
    # Calculate total possible 
    # ways and favourable ways. 
    up = binomialCoeff(2 * n, n)
    down = power(2, 2 * n)
  
    # Divide by gcd such that 
    # they become relatively coprime 
    g = math.gcd(up,down)
  
    up = up // g
    down = down // g
  
    print(up, "/", down)
  
# Driver code 
N = 8
FindProbability(N)
  
# This code is contributed by Sanjit_Prasad

C#

// C# implementation of 
// the above approach 
using System;
using System.Collections.Generic;
      
class GFG
{
      
    // Returns value of Binomial 
    // Coefficient C(n, k) 
    static int binomialCoeff(int n, int k) 
    { 
        int res = 1; 
      
        // Since C(n, k) = C(n, n-k) 
        if (k > n - k) 
            k = n - k; 
      
        // Calculate value of 
        for (int i = 0; i < k; ++i) 
        { 
            res *= (n - i); 
            res /= (i + 1); 
        } 
      
        return res; 
    } 
      
    // Iterative Function to 
    // calculate (x^y) in O(log y) 
    static int power(int x, int y) 
    { 
        // Initialize result 
        int res = 1; 
      
        while (y > 0) 
        { 
      
            // If y is odd, multiply 
            // x with result 
            if ((y & 1) == 1) 
                res = res * x; 
      
            // y must be even now 
            // y = y/2 
            y = y >> 1; 
      
            // Change x to x^2 
            x = x * x; 
        } 
        return res; 
    } 
      
    // Recursive function to
    // return gcd of a and b 
    static int gcd(int a, int b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b); 
    } 
      
    // Function to find probability 
    static void FindProbability(int n) 
    { 
      
        // Calculate total possible 
        // ways and favourable ways. 
        int up = binomialCoeff(2 * n, n); 
        int down = power(2, 2 * n); 
      
        // Divide by gcd such that 
        // they become relatively coprime 
        int g = gcd(up, down); 
      
        up /= g;
        down /= g; 
      
        Console.WriteLine(up + "/" + down); 
    } 
      
    // Driver code 
    public static void Main (String[] args)
    { 
        int N = 8; 
      
        FindProbability(N); 
    } 
}
  
// This code is contributed by 29AjayKumar

输出：

6435/32768