 Open in App
Not now

# Count all subsequences having product less than K

• Difficulty Level : Medium
• Last Updated : 29 Apr, 2022

Given a positive array, find the number of subsequences having product smaller than or equal to K.
Examples:

Input : [1, 2, 3, 4]
k = 10
Output :11
Explanation: The subsequences are {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {1, 2, 3}, {1, 2, 4}

Input  : [4, 8, 7, 2]
k = 50
Output : 9

This problem can be solved using dynamic programming where dp[i][j] = number of subsequences having product less than i using first j terms of the array. Which can be obtained by : number of subsequences using first j-1 terms + number of subsequences that can be formed using j-th term.

Below is the implementation of the above approach:

## C++

 `// CPP program to find number of subarrays having` `// product less than k.` `#include ` `using` `namespace` `std;`   `// Function to count numbers of such subsequences` `// having product less than k.` `int` `productSubSeqCount(vector<``int``> &arr, ``int` `k)` `{` `    ``int` `n = arr.size();` `    ``int` `dp[k + 1][n + 1];` `    ``memset``(dp, 0, ``sizeof``(dp));`   `    ``for` `(``int` `i = 1; i <= k; i++) {` `        ``for` `(``int` `j = 1; j <= n; j++) {` `   `  `            ``// number of subsequence using j-1 terms` `            ``dp[i][j] = dp[i][j - 1];` `  `  `            ``// if arr[j-1] > i it will surely make product greater` `            ``// thus it won't contribute then` `            ``if` `(arr[j - 1] <= i)`   `                ``// number of subsequence using 1 to j-1 terms` `                ``// and j-th term` `                ``dp[i][j] += dp[i/arr[j-1]][j-1] + 1;` `        ``}` `    ``}` `    ``return` `dp[k][n];` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> A;` `    ``A.push_back(1);` `    ``A.push_back(2);` `    ``A.push_back(3);` `    ``A.push_back(4);` `    ``int` `k = 10;` `    ``cout << productSubSeqCount(A, k) << endl;` `}`

## Java

 `// Java program to find number of subarrays ` `// having product less than k.` `import` `java.util.*;` `class` `CountSubsequences` `{` `    ``// Function to count numbers of such ` `    ``// subsequences having product less than k.` `    ``public` `static` `int` `productSubSeqCount(ArrayList arr,` `                                                 ``int` `k)` `    ``{` `        ``int` `n = arr.size();` `        ``int` `dp[][]=``new` `int``[k + ``1``][n + ``1``];` `        `  `        ``for` `(``int` `i = ``1``; i <= k; i++) {` `            ``for` `(``int` `j = ``1``; j <= n; j++) {` `        `  `                ``// number of subsequence using j-1 terms` `                ``dp[i][j] = dp[i][j - ``1``];` `        `  `                ``// if arr[j-1] > i it will surely make ` `                ``// product greater thus it won't contribute` `                ``// then` `                ``if` `(arr.get(j-``1``) <= i && arr.get(j-``1``) > ``0``)` `    `  `                    ``// number of subsequence using 1 to j-1` `                    ``// terms and j-th term` `                    ``dp[i][j] += dp[i/arr.get(j - ``1``)][j - ``1``] + ``1``;` `            ``}` `        ``}` `        ``return` `dp[k][n];` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``ArrayList A = ``new` `ArrayList();` `        ``A.add(``1``);` `        ``A.add(``2``);` `        ``A.add(``3``);` `        ``A.add(``4``);` `        ``int` `k = ``10``;` `        ``System.out.println(productSubSeqCount(A, k));` `    ``}` `}`   `// This Code is contributed by Danish Kaleem`

## Python3

 `# Python3 program to find ` `# number of subarrays having ` `# product less than k. ` `def` `productSubSeqCount(arr, k):` `    ``n ``=` `len``(arr)` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(n ``+` `1``)]` `             ``for` `j ``in` `range``(k ``+` `1``)]` `    ``for` `i ``in` `range``(``1``, k ``+` `1``):` `        ``for` `j ``in` `range``(``1``, n ``+` `1``):` `            `  `            ``# number of subsequence` `            ``# using j-1 terms ` `            ``dp[i][j] ``=` `dp[i][j ``-` `1``]` `            `  `            ``# if arr[j-1] > i it will ` `            ``# surely make product greater` `            ``# thus it won't contribute then ` `            ``if` `arr[j ``-` `1``] <``=` `i ``and` `arr[j ``-` `1``] > ``0``:` `                `  `                ``# number of subsequence` `                ``# using 1 to j-1 terms` `                ``# and j-th term` `                ``dp[i][j] ``+``=` `dp[i ``/``/` `arr[j ``-` `1``]][j ``-` `1``] ``+` `1` `    ``return` `dp[k][n]`   `# Driver code ` `A ``=` `[``1``,``2``,``3``,``4``]` `k ``=` `10` `print``(productSubSeqCount(A, k))`   `# This code is contributed ` `# by pk_tautolo`

## C#

 `// C# program to find number of subarrays ` `// having product less than k. ` `using` `System ;` `using` `System.Collections ;`   `class` `CountSubsequences ` `{ ` `    ``// Function to count numbers of such ` `    ``// subsequences having product less than k. ` `    ``public` `static` `int` `productSubSeqCount(ArrayList arr, ``int` `k) ` `    ``{ ` `        ``int` `n = arr.Count ;` `        ``int` `[,]dp = ``new` `int``[k + 1,n + 1]; ` `        `  `        ``for` `(``int` `i = 1; i <= k; i++) { ` `            ``for` `(``int` `j = 1; j <= n; j++) { ` `        `  `                ``// number of subsequence using j-1 terms ` `                ``dp[i,j] = dp[i,j - 1]; ` `        `  `                ``// if arr[j-1] > i it will surely make ` `                ``// product greater thus it won't contribute ` `                ``// then ` `                ``if` `(Convert.ToInt32(arr[j-1]) <= i && Convert.ToInt32(arr[j-1]) > 0) ` `    `  `                    ``// number of subsequence using 1 to j-1 ` `                    ``// terms and j-th term ` `                    ``dp[i,j] += dp[ i/Convert.ToInt32(arr[j - 1]),j - 1] + 1; ` `            ``} ` `        ``} ` `        ``return` `dp[k,n]; ` `    ``} ` `    `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``ArrayList A = ``new` `ArrayList(); ` `        ``A.Add(1); ` `        ``A.Add(2); ` `        ``A.Add(3); ` `        ``A.Add(4); ` `        ``int` `k = 10; ` `        ``Console.WriteLine(productSubSeqCount(A, k)); ` `    ``} ` `} `   `// This Code is contributed Ryuga `

## Javascript

 ``

Output

`11`

Time Complexity: O(K*N)
Auxiliary Space: O(K*N)
This article is contributed by Raghav Sharma. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.