Count ways to place M objects in distinct partitions of N boxes

• Last Updated : 22 Sep, 2021

Given two positive integers N and M, the task is to find the number of ways to place M distinct objects in partitions of even indexed boxes which are numbered [1, N] sequentially, and every ith Box has i distinct partitions. Since the answer can be very large, print modulo 1000000007.

Examples:

Input: N = 2, M = 1
Output: 2
Explanation: Since, N = 2. There is only one even indexed box i.e box 2, having 2 partitions. Therefore, there are two positions to place an object. Therefore, number of ways = 2.

Input: N = 5, M = 2
Output: 32

Approach: Follow the steps below to solve the problem:

• M objects are to be placed in even indexed box’s partitions. Let S be the total even indexed box’s partitions in N boxes.
• The number of partitions is equal to the summation of all even numbers up to N. Therefore, Sum, S = X * (X + 1), where X = floor(N / 2).
• Each object can occupy one of S different positions. Therefore, the total number of ways = S*S*S..(M times) = SM.

Below is the implementation of the above approach:

C++

 // C++ implementation of the // above Approach   #include using namespace std;   const int MOD = 1000000007;   // Iterative Function to calculate // (x^y)%p in O(log y) int power(int x, unsigned int y, int p = MOD) {     // Initialize Result     int res = 1;       // Update x if x >= MOD     // to avoid multiplication overflow     x = x % p;       while (y > 0) {           // If y is odd, multiply x with result         if (y & 1)             res = (res * 1LL * x) % p;           // multiplied by long long int,         // to avoid overflow         // because res * x <= 1e18, which is         // out of bounds for integer           // n must be even now           // y = y/2         y = y >> 1;           // Change x to x^2         x = (x * 1LL * x) % p;     }     return res; }   // Utility function to find // the Total Number of Ways void totalWays(int N, int M) {     // Number of Even Indexed     // Boxes     int X = N / 2;       // Number of partitions of     // Even Indexed Boxes     int S = (X * 1LL * (X + 1)) % MOD;       // Number of ways to distribute     // objects     cout << power(S, M, MOD) << "\n"; }   // Driver Code int main() {     // N = number of boxes     // M = number of distinct objects     int N = 5, M = 2;       // Function call to     // get Total Number of Ways     totalWays(N, M);       return 0; }

Java

 // Java implementation of the // above Approach import java.io.*; class GFG {     public static int MOD = 1000000007;   // Iterative Function to calculate // (x^y)%p in O(log y) static int power(int x, int y, int p) {          p = MOD;         // Initialize Result     int res = 1;       // Update x if x >= MOD     // to avoid multiplication overflow     x = x % p;       while (y > 0)     {           // If y is odd, multiply x with result         if ((y & 1) != 0)             res = (res * x) % p;           // multiplied by long long int,         // to avoid overflow         // because res * x <= 1e18, which is         // out of bounds for integer           // n must be even now           // y = y/2         y = y >> 1;           // Change x to x^2         x = (x * x) % p;     }     return res; }   // Utility function to find // the Total Number of Ways static void totalWays(int N, int M) {         // Number of Even Indexed     // Boxes     int X = N / 2;       // Number of partitions of     // Even Indexed Boxes     int S = (X * (X + 1)) % MOD;       // Number of ways to distribute     // objects     System.out.println(power(S, M, MOD)); }   // Driver Code public static void main (String[] args) {             // N = number of boxes     // M = number of distinct objects     int N = 5, M = 2;       // Function call to     // get Total Number of Ways     totalWays(N, M); } }   // This code is contributed by Dharanendra L V

Python3

 # Python3 implementation of the # above Approach MOD = 1000000007   # Iterative Function to calculate # (x^y)%p in O(log y) def power(x, y, p = MOD):         # Initialize Result     res = 1       # Update x if x >= MOD     # to avoid multiplication overflow     x = x % p     while (y > 0):           # If y is odd, multiply x with result         if (y & 1):             res = (res * x) % p           # multiplied by long long int,         # to avoid overflow         # because res * x <= 1e18, which is         # out of bounds for integer           # n must be even now           # y = y/2         y = y >> 1           # Change x to x^2         x = (x * x) % p     return res   # Utility function to find # the Total Number of Ways def totalWays(N, M):         # Number of Even Indexed     # Boxes     X = N // 2       # Number of partitions of     # Even Indexed Boxes     S = (X * (X + 1)) % MOD       # Number of ways to distribute     # objects     print (power(S, M, MOD))   # Driver Code if __name__ == '__main__':       # N = number of boxes     # M = number of distinct objects     N, M = 5, 2       # Function call to     # get Total Number of Ways     totalWays(N, M)   # This code is contributed by mohit kumar 29.

C#

 // C# implementation of the // above Approach   using System;   public class GFG{   public static int MOD = 1000000007;   // Iterative Function to calculate // (x^y)%p in O(log y) static int power(int x, int y, int p) {               p = MOD;         // Initialize Result     int res = 1;       // Update x if x >= MOD     // to avoid multiplication overflow     x = x % p;       while (y > 0) {           // If y is odd, multiply x with result         if ((y & 1) != 0)             res = (res * x) % p;           // multiplied by long long int,         // to avoid overflow         // because res * x <= 1e18, which is         // out of bounds for integer           // n must be even now           // y = y/2         y = y >> 1;           // Change x to x^2         x = (x * x) % p;     }     return res; }   // Utility function to find // the Total Number of Ways static void totalWays(int N, int M) {         // Number of Even Indexed     // Boxes     int X = N / 2;       // Number of partitions of     // Even Indexed Boxes     int S = (X * (X + 1)) % MOD;       // Number of ways to distribute     // objects     Console.WriteLine(power(S, M, MOD)); }   // Driver Code static public void Main () {       // N = number of boxes     // M = number of distinct objects     int N = 5, M = 2;       // Function call to     // get Total Number of Ways     totalWays(N, M); } }   // This code is contributed by Dharanendra L V

Javascript



Output:

36

Time Complexity: O(log M)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :