在R个不同的组中分配N个相同对象的方式数量

给定两个整数N和R ，任务是计算将N个相同的对象分布到R个不同的组中的方式的数量。

例子：

Input: N = 4, R = 2 
Output: 5 
No of objects in 1st group = 0, in second group = 4 
No of objects in 1st group = 1, in second group = 3 
No of objects in 1st group = 2, in second group = 2 
No of objects in 1st group = 3, in second group = 1 
No of objects in 1st group = 4, in second group = 0

Input: N = 4, R = 3 
Output: 15 

方法：想法是使用多项式定理。让我们假设将x _1个对象放置在第一组中，将x _2个对象放置在第二组中，将x个_R对象放置在第R^个组中。据认为，
x ₁ + x ₂ + x ₃ +…+ x _R = N
^{N + R – 1} C _{R – 1}给出多项式定理对该方程的解。

下面是上述方法的实现：

C++

// C++ implementation of the above approach
#include 
using namespace std;
 
// Function to return the
// value of ncr effectively
int ncr(int n, int r)
{
 
    // Initialize the answer
    int ans = 1;
 
    for (int i = 1; i <= r; i += 1)
    {
        // Divide simultaneously by
        // i to avoid overflow
        ans *= (n - r + i);
        ans /= i;
    }
    return ans;
}
 
// Function to return the number of
// ways to distribute N identical
// objects in R distinct objects
int NoOfDistributions(int N, int R)
{
    return ncr(N + R - 1, R - 1);
}
 
// Driver code
int main()
{
    int N = 4, R = 3;
 
    // Function call
    cout << NoOfDistributions(N, R);
 
    return 0;
}

Java

// Java implementation of the above approach
import java.util.*;
 
class GFG {
 
    // Function to return the
    // value of ncr effectively
    static int ncr(int n, int r)
    {
 
        // Initialize the answer
        int ans = 1;
 
        for (int i = 1; i <= r; i += 1)
        {
            // Divide simultaneously by
            // i to avoid overflow
            ans *= (n - r + i);
            ans /= i;
        }
        return ans;
    }
 
    // Function to return the number of
    // ways to distribute N identical
    // objects in R distinct objects
    static int NoOfDistributions(int N, int R)
    {
        return ncr(N + R - 1, R - 1);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 4, R = 3;
       
        // Function call
        System.out.println(NoOfDistributions(N, R));
    }
}
 
// This code is contributed by Princi Singh

Python3

# Python3 implementation of the above approach
 
# Function to return the
# value of ncr effectively
 
 
def ncr(n, r):
 
    # Initialize the answer
    ans = 1
 
    for i in range(1, r+1):
 
        # Divide simultaneously by
        # i to avoid overflow
        ans *= (n - r + i)
        ans //= i
 
    return ans
 
 
# Function to return the number of
# ways to distribute N identical
# objects in R distinct objects
def NoOfDistributions(N, R):
 
    return ncr(N + R-1, R - 1)
 
 
# Driver code
N = 4
R = 3
 
# Function call
print(NoOfDistributions(N, R))
 
# This code is contributed by mohit kumar 29

C#

// C# implementation of the above approach
using System;
 
class GFG {
 
    // Function to return the
    // value of ncr effectively
    static int ncr(int n, int r)
    {
 
        // Initialize the answer
        int ans = 1;
 
        for (int i = 1; i <= r; i += 1)
        {
            // Divide simultaneously by
            // i to avoid overflow
            ans *= (n - r + i);
            ans /= i;
        }
        return ans;
    }
 
    // Function to return the number of
    // ways to distribute N identical
    // objects in R distinct objects
    static int NoOfDistributions(int N, int R)
    {
        return ncr(N + R - 1, R - 1);
    }
 
    // Driver code
    static public void Main()
    {
        int N = 4, R = 3;
       
        // Function call
        Console.WriteLine(NoOfDistributions(N, R));
    }
}
 
// This code is contributed by AnkitRai01

输出

15

时间复杂度： O(R)