Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Count all subsequences having product less than K

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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up