 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.