# Count all sub-sequences having product <= K – Recursive approach

Given an integer K and a non negative array arr[], the task is to find the number of sub-sequences having product ≤ K.
This problem already has a dynamic programming solution. This solution aims to provide an optimized recursive strategy to the problem.

Examples:

Input: arr[] = { 1, 2, 3, 4 }, K = 10
Output: 11
The sub-sequences are {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {1, 2, 3}, {1, 2, 4}

Input: arr[] = { 4, 8, 7, 2 }, K = 50
Output: 9

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Convert the product problem to a sum problem by performing the conversions arr[i] = log(arr[i]) and K = log(K). Generate all subsets and store the sum of elements that have been taken in the sub-sequence. If at any point, the sum becomes larger than K, then we know that if we add another element to the sub-sequence, its sum will also be larger than K. Therefore, we discard all such sub-sequences that have sum larger than K without making a recursive call for them. Also if we currently have sum less than K then we check if there are any chances to further discard any sub-sequences. If any further sub-sequences can’t be discarded then no recursive calls are made.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach. ` `#include ` ` `  `#define ll long long ` ` `  `using` `namespace` `std; ` ` `  `// This variable counts discarded subsequences ` `ll discard_count = 0; ` ` `  `// Function to return a^n ` `ll power(ll a, ll n) ` `{ ` `    ``if` `(n == 0) ` `        ``return` `1; ` `    ``ll p = power(a, n / 2); ` `    ``p = p * p; ` `    ``if` `(n & 1) ` `        ``p = p * a; ` `    ``return` `p; ` `} ` ` `  `// Recursive function that counts discarded  ` `// subsequences ` `void` `solve(``int` `i, ``int` `n, ``float` `sum, ``float` `k, ` `                   ``float``* a, ``float``* prefix) ` `{ ` ` `  `    ``// If at any stage, sum > k ` `    ``// discard further subsequences ` `    ``if` `(sum > k) { ` `        ``discard_count += power(2, n - i); ` ` `  `        ``// Recursive call terminated ` `        ``// No further calls ` `        ``return``; ` `    ``} ` ` `  `    ``if` `(i == n) ` `        ``return``; ` ` `  `    ``// rem = Sum of array[i+1...n-1] ` `    ``float` `rem = prefix[n - 1] - prefix[i]; ` ` `  `    ``// If there are chances of discarding  ` `    ``// further subsequences then make a ` `    ``// recursive call, otherwise not ` `    ``// Including a[i] ` `    ``if` `(sum + a[i] + rem > k) ` `        ``solve(i + 1, n, sum + a[i], k, ` `                          ``a, prefix); ` ` `  `    ``// Excluding a[i] ` `    ``if` `(sum + rem > k) ` `        ``solve(i + 1, n, sum, k, a, prefix); ` `} ` ` `  `// Function to return count of non-empty  ` `// subsequences whose product doesn't ` `// exceed k ` `int` `countSubsequences(``const` `int``* arr,  ` `                         ``int` `n, ll K) ` `{ ` `    ``float` `sum = 0.0; ` ` `  `    ``// Converting k to log(k) ` `    ``float` `k = log2(K); ` ` `  `    ``// Prefix sum array and array to ` `    ``// store log values. ` `    ``float` `prefix[n], a[n]; ` ` `  `    ``// a[] is the array obtained ` `    ``// after converting numbers to  ` `    ``// logarithms ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``a[i] = log2(arr[i]); ` `        ``sum += a[i]; ` `    ``} ` ` `  `    ``// Computing prefix sums ` `    ``prefix = a; ` `    ``for` `(``int` `i = 1; i < n; i++) { ` `        ``prefix[i] = prefix[i - 1] + a[i]; ` `    ``} ` ` `  `    ``// Calculate non-empty subsequences ` `    ``// hence 1 is subtracted ` `    ``ll total = power(2, n) - 1; ` ` `  `    ``// If total sum is <= k, then  ` `    ``// answer = 2^n - 1 ` `    ``if` `(sum <= k) { ` `        ``return` `total; ` `    ``} ` ` `  `    ``solve(0, n, 0.0, k, a, prefix); ` `    ``return` `total - discard_count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 4, 8, 7, 2 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``ll k = 50; ` `    ``cout << countSubsequences(arr, n, k); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach. ` `class` `GFG ` `{ ` ` `  `// This variable counts discarded subsequences ` `static` `long` `discard_count = ``0``; ` ` `  `// Function to return a^n ` `static` `long` `power(``long` `a, ``long` `n) ` `{ ` `    ``if` `(n == ``0``) ` `        ``return` `1``; ` `    ``long` `p = power(a, n / ``2``); ` `    ``p = p * p; ` `    ``if` `(n % ``2` `== ``1``) ` `        ``p = p * a; ` `    ``return` `p; ` `} ` ` `  `// Recursive function that counts discarded  ` `// subsequences ` `static` `void` `solve(``int` `i, ``int` `n, ``float` `sum, ``float` `k, ` `                ``float` `[]a, ``float` `[]prefix) ` `{ ` ` `  `    ``// If at any stage, sum > k ` `    ``// discard further subsequences ` `    ``if` `(sum > k)  ` `    ``{ ` `        ``discard_count += power(``2``, n - i); ` ` `  `        ``// Recursive calong terminated ` `        ``// No further calongs ` `        ``return``; ` `    ``} ` ` `  `    ``if` `(i == n) ` `        ``return``; ` ` `  `    ``// rem = Sum of array[i+1...n-1] ` `    ``float` `rem = prefix[n - ``1``] - prefix[i]; ` ` `  `    ``// If there are chances of discarding  ` `    ``// further subsequences then make a ` `    ``// recursive calong, otherwise not ` `    ``// Including a[i] ` `    ``if` `(sum + a[i] + rem > k) ` `        ``solve(i + ``1``, n, sum + a[i], k, ` `                        ``a, prefix); ` ` `  `    ``// Excluding a[i] ` `    ``if` `(sum + rem > k) ` `        ``solve(i + ``1``, n, sum, k, a, prefix); ` `} ` ` `  `// Function to return count of non-empty  ` `// subsequences whose product doesn't ` `// exceed k ` `static` `int` `countSubsequences(``int` `[]arr,  ` `                        ``int` `n, ``long` `K) ` `{ ` `    ``float` `sum = ``0``.0f; ` ` `  `    ``// Converting k to log(k) ` `    ``float` `k = (``float``) Math.log(K); ` ` `  `    ``// Prefix sum array and array to ` `    ``// store log values. ` `    ``float` `[]prefix = ``new` `float``[n]; ` `    ``float` `[]a = ``new` `float``[n]; ` ` `  `    ``// a[] is the array obtained ` `    ``// after converting numbers to  ` `    ``// logarithms ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``a[i] = (``float``) Math.log(arr[i]); ` `        ``sum += a[i]; ` `    ``} ` ` `  `    ``// Computing prefix sums ` `    ``prefix[``0``] = a[``0``]; ` `    ``for` `(``int` `i = ``1``; i < n; i++) ` `    ``{ ` `        ``prefix[i] = prefix[i - ``1``] + a[i]; ` `    ``} ` ` `  `    ``// Calculate non-empty subsequences ` `    ``// hence 1 is subtracted ` `    ``long` `total = power(``2``, n) - ``1``; ` ` `  `    ``// If total sum is <= k, then  ` `    ``// answer = 2^n - 1 ` `    ``if` `(sum <= k)  ` `    ``{ ` `        ``return` `(``int``) total; ` `    ``} ` ` `  `    ``solve(``0``, n, ``0``.0f, k, a, prefix); ` `    ``return` `(``int``) (total - discard_count); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { ``4``, ``8``, ``7``, ``2` `}; ` `    ``int` `n = arr.length; ` `    ``long` `k = ``50``; ` `    ``System.out.print(countSubsequences(arr, n, k)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 implementation of the  ` `# above approach.  ` ` `  `# From math lib import log2 ` `from` `math ``import` `log2 ` ` `  `# This variable counts discarded ` `# subsequences  ` `discard_count ``=` `0` ` `  `# Function to return a^n  ` `def` `power(a, n) : ` `     `  `    ``if` `(n ``=``=` `0``) : ` `        ``return` `1` `         `  `    ``p ``=` `power(a, n ``/``/` `2``) ` `    ``p ``=` `p ``*` `p ` `    ``if` `(n & ``1``) : ` `        ``p ``=` `p ``*` `a  ` `    ``return` `p  ` ` `  `# Recursive function that counts  ` `# discarded subsequences  ` `def` `solve(i, n, ``sum``, k, a, prefix) : ` `    ``global` `discard_count ` `     `  `    ``# If at any stage, sum > k ` `    ``# discard further subsequences ` `    ``if` `(``sum` `> k) : ` `        ``discard_count ``+``=` `power(``2``, n ``-` `i) ` `         `  `        ``# Recursive call terminated ` `        ``# No further calls  ` `        ``return``;  ` `     `  `    ``if` `(i ``=``=` `n) : ` `        ``return` `     `  `    ``# rem = Sum of array[i+1...n-1] ` `    ``rem ``=` `prefix[n ``-` `1``] ``-` `prefix[i] ` `     `  `    ``# If there are chances of discarding ` `    ``# further subsequences then make a  ` `    ``# recursive call, otherwise not  ` `    ``# Including a[i] ` `    ``if` `(``sum` `+` `a[i] ``+` `rem > k) : ` `        ``solve(i ``+` `1``, n, ``sum` `+` `a[i], k, a, prefix)  ` `     `  `    ``# Excluding a[i]  ` `    ``if` `(``sum` `+` `rem > k) : ` `        ``solve(i ``+` `1``, n, ``sum``, k, a, prefix) ` ` `  `# Function to return count of non-empty  ` `# subsequences whose product doesn't  ` `# exceed k  ` `def` `countSubsequences(arr, n, K) : ` `     `  `    ``sum` `=` `0.0` ` `  `    ``# Converting k to log(k)  ` `    ``k ``=` `log2(K) ` ` `  `    ``# Prefix sum array and array to  ` `    ``# store log values.  ` `    ``prefix ``=` `[``0``] ``*` `n ` `    ``a ``=` `[``0``] ``*` `n ` ` `  `    ``# a[] is the array obtained after  ` `    ``# converting numbers to logarithms  ` `    ``for` `i ``in` `range``(n) :  ` `        ``a[i] ``=` `log2(arr[i])  ` `        ``sum` `+``=` `a[i] ` `     `  `    ``# Computing prefix sums  ` `    ``prefix[``0``] ``=` `a[``0``] ` `     `  `    ``for` `i ``in` `range``(``1``, n) :  ` `        ``prefix[i] ``=` `prefix[i ``-` `1``] ``+` `a[i] ` ` `  `    ``# Calculate non-empty subsequences  ` `    ``# hence 1 is subtracted  ` `    ``total ``=` `power(``2``, n) ``-` `1` ` `  `    ``# If total sum is <= k, then  ` `    ``# answer = 2^n - 1  ` `    ``if` `(``sum` `<``=` `k) :  ` `        ``return` `total ` ` `  `    ``solve(``0``, n, ``0.0``, k, a, prefix) ` `    ``return` `total ``-` `discard_count  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``arr ``=` `[ ``4``, ``8``, ``7``, ``2` `]  ` `    ``n ``=` `len``(arr) ` `    ``k ``=` `50``;  ` `    ``print``(countSubsequences(arr, n, k)) ` ` `  `# This code is contributed by Ryuga `

## C#

 `// C# implementation of the above approach. ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// This variable counts discarded subsequences ` `static` `long` `discard_count = 0; ` ` `  `// Function to return a^n ` `static` `long` `power(``long` `a, ``long` `n) ` `{ ` `    ``if` `(n == 0) ` `        ``return` `1; ` `    ``long` `p = power(a, n / 2); ` `    ``p = p * p; ` `    ``if` `(n % 2 == 1) ` `        ``p = p * a; ` `    ``return` `p; ` `} ` ` `  `// Recursive function that counts discarded  ` `// subsequences ` `static` `void` `solve(``int` `i, ``int` `n, ``float` `sum, ``float` `k, ` `                     ``float` `[]a, ``float` `[]prefix) ` `{ ` ` `  `    ``// If at any stage, sum > k ` `    ``// discard further subsequences ` `    ``if` `(sum > k)  ` `    ``{ ` `        ``discard_count += power(2, n - i); ` ` `  `        ``// Recursive calong terminated ` `        ``// No further calongs ` `        ``return``; ` `    ``} ` ` `  `    ``if` `(i == n) ` `        ``return``; ` ` `  `    ``// rem = Sum of array[i+1...n-1] ` `    ``float` `rem = prefix[n - 1] - prefix[i]; ` ` `  `    ``// If there are chances of discarding  ` `    ``// further subsequences then make a ` `    ``// recursive calong, otherwise not ` `    ``// Including a[i] ` `    ``if` `(sum + a[i] + rem > k) ` `        ``solve(i + 1, n, sum + a[i], k, ` `                           ``a, prefix); ` ` `  `    ``// Excluding a[i] ` `    ``if` `(sum + rem > k) ` `        ``solve(i + 1, n, sum, k, a, prefix); ` `} ` ` `  `// Function to return count of non-empty  ` `// subsequences whose product doesn't ` `// exceed k ` `static` `int` `countSubsequences(``int` `[]arr,  ` `                             ``int` `n, ``long` `K) ` `{ ` `    ``float` `sum = 0.0f; ` ` `  `    ``// Converting k to log(k) ` `    ``float` `k = (``float``) Math.Log(K); ` ` `  `    ``// Prefix sum array and array to ` `    ``// store log values. ` `    ``float` `[]prefix = ``new` `float``[n]; ` `    ``float` `[]a = ``new` `float``[n]; ` ` `  `    ``// []a is the array obtained ` `    ``// after converting numbers to  ` `    ``// logarithms ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``a[i] = (``float``) Math.Log(arr[i]); ` `        ``sum += a[i]; ` `    ``} ` ` `  `    ``// Computing prefix sums ` `    ``prefix = a; ` `    ``for` `(``int` `i = 1; i < n; i++) ` `    ``{ ` `        ``prefix[i] = prefix[i - 1] + a[i]; ` `    ``} ` ` `  `    ``// Calculate non-empty subsequences ` `    ``// hence 1 is subtracted ` `    ``long` `total = power(2, n) - 1; ` ` `  `    ``// If total sum is <= k, then  ` `    ``// answer = 2^n - 1 ` `    ``if` `(sum <= k)  ` `    ``{ ` `        ``return` `(``int``) total; ` `    ``} ` ` `  `    ``solve(0, n, 0.0f, k, a, prefix); ` `    ``return` `(``int``) (total - discard_count); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { 4, 8, 7, 2 }; ` `    ``int` `n = arr.Length; ` `    ``long` `k = 50; ` `    ``Console.Write(countSubsequences(arr, n, k)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## PHP

 ` k ` `    ``// discard further subsequences ` `    ``if` `(``\$sum` `> ``\$k``)  ` `    ``{ ` `        ``\$discard_count` `+= power(2, ``\$n` `- ``\$i``); ` ` `  `        ``// Recursive call terminated ` `        ``// No further calls ` `        ``return``; ` `    ``} ` ` `  `    ``if` `(``\$i` `== ``\$n``) ` `        ``return``; ` ` `  `    ``// rem = Sum of array[i+1...n-1] ` `    ``\$rem` `= ``\$prefix``[``\$n` `- 1] - ``\$prefix``[``\$i``]; ` ` `  `    ``// If there are chances of discarding  ` `    ``// further subsequences then make a ` `    ``// recursive call, otherwise not ` `    ``// Including a[i] ` `    ``if` `(``\$sum` `+ ``\$a``[``\$i``] + ``\$rem` `> ``\$k``) ` `        ``solve(``\$i` `+ 1, ``\$n``, ``\$sum` `+ ``\$a``[``\$i``], ``\$k``, ` `                               ``\$a``, ``\$prefix``); ` ` `  `    ``// Excluding a[i] ` `    ``if` `(``\$sum` `+ ``\$rem` `> ``\$k``) ` `        ``solve(``\$i` `+ 1, ``\$n``, ``\$sum``, ``\$k``, ``\$a``, ``\$prefix``); ` `} ` ` `  `// Function to return count of non-empty  ` `// subsequences whose product doesn't ` `// exceed k ` `function` `countSubsequences(&``\$arr``, ``\$n``, ``\$K``) ` `{ ` `    ``global` `\$discard_count``; ` `    ``\$sum` `= 0.0; ` ` `  `    ``// Converting k to log(k) ` `    ``\$k` `= log(``\$K``, 2); ` ` `  `    ``// Prefix sum array and array to ` `    ``// store log values. ` `    ``\$prefix` `= ``array_fill``(0, ``\$n``, NULL); ` `    ``\$a` `= ``array_fill``(0, ``\$n``, NULL); ` ` `  `    ``// a[] is the array obtained after  ` `    ``// converting numbers to logarithms ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)  ` `    ``{ ` `        ``\$a``[``\$i``] = log(``\$arr``[``\$i``], 2); ` `        ``\$sum` `+= ``\$a``[``\$i``]; ` `    ``} ` ` `  `    ``// Computing prefix sums ` `    ``\$prefix`` = ``\$a``; ` `    ``for` `(``\$i` `= 1; ``\$i` `< ``\$n``; ``\$i``++)  ` `    ``{ ` `        ``\$prefix``[``\$i``] = ``\$prefix``[``\$i` `- 1] + ``\$a``[``\$i``]; ` `    ``} ` ` `  `    ``// Calculate non-empty subsequences ` `    ``// hence 1 is subtracted ` `    ``\$total` `= power(2, ``\$n``) - 1; ` ` `  `    ``// If total sum is <= k, then  ` `    ``// answer = 2^n - 1 ` `    ``if` `(``\$sum` `<= ``\$k``)  ` `    ``{ ` `        ``return` `\$total``; ` `    ``} ` ` `  `    ``solve(0, ``\$n``, 0.0, ``\$k``, ``\$a``, ``\$prefix``); ` `    ``return` `\$total` `- ``\$discard_count``; ` `} ` ` `  `// Driver code ` `\$arr` `= ``array``(4, 8, 7, 2 ); ` `\$n` `= sizeof(``\$arr``); ` `\$k` `= 50; ` `echo` `countSubsequences(``\$arr``, ``\$n``, ``\$k``); ` ` `  `// This code is contributed by ita_c ` `?> `

Output:

```9
```

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 Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.