Related Articles
Count sequences of positive integers having product X
• Last Updated : 01 Feb, 2021

Given an array arr[] of size N, the task is to find the total number of sequences of positive integers possible (greater than 1) whose product is exactly X. The value of X is calculated as the product of the terms where ith term is generated by raising ith prime number to the power of arr[i].

X = 2 ^ arr * 3 ^ arr * 5 ^ arr * 7 ^ arr * 11 ^ arr * … up to Nth term

Note: As the number of a total number of such sequences can be very large, print the answer modulo 109 + 7.

Examples:

Input: arr[] = {1, 1}
Output:
Explanation:
Here, X = 2^1 * 3^1 = 6
Possible positive sequences whose product is X: {2, 3}, {3, 2}, {6}

Input: arr[] = {2}
Output:
Explanation:
Here, X = 2^2 = 4.
Possible positive sequences whose product is X: {2, 2} and {4}.

Naive Approach: The idea is to first calculate the value of X and then generate all possible sequences whose product is X using recursion.

Time Complexity: O(2N
Auxiliary Space: O(1)

Efficient Approach: This problem can be solved using Dynamic Programming and Combinatorics Approach. Below are the steps:

• First, find the maximum number of positive elements that can appear in all of the possible sequences which will be the sum of given array arr[].
• Then use dynamic programming to fill the slots in the possible sequences starting index i from 1 to length of the sequence.
• For each j-th prime number having value as P[j], divide all the P[j] primes into each of the i slots.
• Use the Combinatorics Approach to divide P[j] elements into i slots. Store the value in array ways[] such that ways[i] is updated as follows: Number of ways to divide N identical elements into K slots = (N + K – 1)C(K – 1)
This approach is also known as Stars and Bars approach formally in Combinatorics.

• For each of the j primes, multiply the values as depicted by the multiplication.
• However, ways[] will also contain the sequences with one or more than 1 slot empty, hence subtract the exact contribution for all slots where number of slots filled is less than i.
• For each of the slots from j = 1 to i – 1, select j slots from i and subtract its contribution. • Finally, add all the values of the array ways[] to get the total result.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `bin;` `// Function to print the total number``// of possible sequences with``// product X``void` `countWays(``const` `vector<``int``>& arr)``{``    ``int` `mod = 1e9 + 7;``    ``bin = 1;` `    ``// Precomputation of``    ``// binomial coefficients``    ``for` `(``int` `i = 1; i < 3000; i++) {``        ``bin[i] = 1;``        ``for` `(``int` `j = 1; j <= i; j++) {``            ``bin[i][j] = (bin[i - 1][j]``                         ``+ bin[i - 1][j - 1])``                        ``% mod;``        ``}``    ``}` `    ``// Max length of a subsequence``    ``int` `n = 0;``    ``for` `(``auto` `x : arr)``        ``n += x;` `    ``// Ways dp array``    ``vector<``int``> ways(n + 1);` `    ``for` `(``int` `i = 1; i <= n; i++) {``        ``ways[i] = 1;` `        ``// Fill i slots using all``        ``// the primes``        ``for` `(``int` `j = 0;``             ``j < (``int``)arr.size(); j++) {``            ``ways[i] = (ways[i]``                       ``* bin[arr[j] + i - 1]``                            ``[i - 1])``                      ``% mod;``        ``}` `        ``// Subtract ways for all``        ``// slots that exactly``        ``// fill less than i slots``        ``for` `(``int` `j = 1; j < i; j++) {``            ``ways[i] = ((ways[i]``                        ``- bin[i][j] * ways[j])``                           ``% mod``                       ``+ mod)``                      ``% mod;``        ``}``    ``}` `    ``// Total possible sequences``    ``int` `ans = 0;``    ``for` `(``auto` `x : ways)``        ``ans = (ans + x) % mod;` `    ``// Print the resultant count``    ``cout << ans << endl;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 1, 1 };` `    ``// Function call``    ``countWays(arr);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `static` `int` `[][]bin = ``new` `int``[``3000``][``3000``];` `// Function to print the total number``// of possible sequences with``// product X``static` `void` `countWays(``int``[] arr)``{``    ``int` `mod = (``int``)1e9 + ``7``;``    ``bin[``0``][``0``] = ``1``;` `    ``// Precomputation of``    ``// binomial coefficients``    ``for``(``int` `i = ``1``; i < ``3000``; i++)``    ``{``        ``bin[i][``0``] = ``1``;``        ``for``(``int` `j = ``1``; j <= i; j++)``        ``{``            ``bin[i][j] = (bin[i - ``1``][j] +``                         ``bin[i - ``1``][j - ``1``]) % mod;``        ``}``    ``}` `    ``// Max length of a subsequence``    ``int` `n = ``0``;``    ``for``(``int` `x : arr)``        ``n += x;` `    ``// Ways dp array``    ``int``[] ways = ``new` `int``[n + ``1``];` `    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``ways[i] = ``1``;` `        ``// Fill i slots using all``        ``// the primes``        ``for``(``int` `j = ``0``; j < arr.length; j++)``        ``{``            ``ways[i] = (ways[i] *``                    ``bin[arr[j] + i - ``1``][i - ``1``]) % mod;``        ``}` `        ``// Subtract ways for all``        ``// slots that exactly``        ``// fill less than i slots``        ``for``(``int` `j = ``1``; j < i; j++)``        ``{``            ``ways[i] = ((ways[i] - bin[i][j] *``                        ``ways[j]) % mod + mod) % mod;``        ``}``    ``}` `    ``// Total possible sequences``    ``int` `ans = ``0``;``    ``for``(``int` `x : ways)``        ``ans = (ans + x) % mod;` `    ``// Print the resultant count``    ``System.out.print(ans + ``"\n"``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr = { ``1``, ``1` `};` `    ``// Function call``    ``countWays(arr);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach``bin` `=` `[[``0` `for` `i ``in` `range``(``3000``)]``          ``for` `i ``in` `range``(``3000``)]` `# Function to prthe total number``# of possible sequences with``# product X``def` `countWays(arr):``    ` `    ``mod ``=` `10``*``*``9` `+` `7``    ``bin``[``0``][``0``] ``=` `1` `    ``# Precomputation of``    ``# binomial coefficients``    ``for` `i ``in` `range``(``1``, ``3000``):``        ``bin``[i][``0``] ``=` `1``        ` `        ``for` `j ``in` `range``(``1``, i ``+` `1``):``            ``bin``[i][j] ``=` `(``bin``[i ``-` `1``][j] ``+``                         ``bin``[i ``-` `1``][j ``-` `1``]) ``%` `mod` `    ``# Max length of a subsequence``    ``n ``=` `0``    ` `    ``for` `x ``in` `arr:``        ``n ``+``=` `x` `    ``# Ways dp array``    ``ways ``=` `[``0``] ``*` `(n ``+` `1``)` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``ways[i] ``=` `1` `        ``# Fill i slots using all``        ``# the primes``        ``for` `j ``in` `range``(``len``(arr)):``            ``ways[i] ``=` `(ways[i] ``*``                    ``bin``[arr[j] ``+` `i ``-` `1``][i ``-` `1``]) ``%` `mod` `        ``# Subtract ways for all``        ``# slots that exactly``        ``# fill less than i slots``        ``for` `j ``in` `range``(``1``, i):``            ``ways[i] ``=` `((ways[i] ``-` `bin``[i][j] ``*``                        ``ways[j]) ``%` `mod ``+` `mod) ``%` `mod` `    ``# Total possible sequences``    ``ans ``=` `0``    ` `    ``for` `x ``in` `ways:``        ``ans ``=` `(ans ``+` `x) ``%` `mod` `    ``# Print the resultant count``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``1` `]` `    ``# Function call``    ``countWays(arr)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `static` `int` `[,]bin = ``new` `int``[3000, 3000];` `// Function to print the total number``// of possible sequences with``// product X``static` `void` `countWays(``int``[] arr)``{``    ``int` `mod = (``int``)1e9 + 7;``    ``bin[0, 0] = 1;` `    ``// Precomputation of``    ``// binomial coefficients``    ``for``(``int` `i = 1; i < 3000; i++)``    ``{``        ``bin[i, 0] = 1;``        ``for``(``int` `j = 1; j <= i; j++)``        ``{``            ``bin[i, j] = (bin[i - 1, j] +``                         ``bin[i - 1, j - 1]) % mod;``        ``}``    ``}` `    ``// Max length of a subsequence``    ``int` `n = 0;``    ``foreach``(``int` `x ``in` `arr)``        ``n += x;` `    ``// Ways dp array``    ``int``[] ways = ``new` `int``[n + 1];` `    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``ways[i] = 1;` `        ``// Fill i slots using all``        ``// the primes``        ``for``(``int` `j = 0; j < arr.Length; j++)``        ``{``            ``ways[i] = (ways[i] *``                    ``bin[arr[j] + i - 1, i - 1]) % mod;``        ``}` `        ``// Subtract ways for all``        ``// slots that exactly``        ``// fill less than i slots``        ``for``(``int` `j = 1; j < i; j++)``        ``{``            ``ways[i] = ((ways[i] - bin[i, j] *``                        ``ways[j]) % mod + mod) % mod;``        ``}``    ``}` `    ``// Total possible sequences``    ``int` `ans = 0;``    ``foreach``(``int` `x ``in` `ways)``        ``ans = (ans + x) % mod;` `    ``// Print the resultant count``    ``Console.Write(ans + ``"\n"``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int``[] arr = { 1, 1 };` `    ``// Function call``    ``countWays(arr);``}``}` `// This code is contributed by Amit Katiyar`
Output
```3
```

Time Complexity: O(N2
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up