Skip to content
Related Articles

Related Articles

Improve Article

Count all subsequences having product less than K

  • Difficulty Level : Medium
  • Last Updated : 17 Aug, 2021
Geek Week

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

Input : [1, 2, 3, 4] 
        k = 10
Output :11 
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. 
 

C++




// CPP program to find number of subarrays having
// product less than k.
#include <bits/stdc++.h>
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<Integer> 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<Integer> A = new ArrayList<Integer>();
        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




<script>
    // Javascript program to find number of subarrays
    // having product less than k.
     
    // Function to count numbers of such
    // subsequences having product less than k.
    function productSubSeqCount(arr, k)
    {
        let n = arr.length;
        let dp = new Array(k + 1);
        for (let i = 0; i < k + 1; i++)
        {
            dp[i] = new Array(n + 1);
            for (let j = 0; j < n + 1; j++)
            {
                dp[i][j] = 0;
            }
        }
           
        for (let i = 1; i <= k; i++) {
            for (let 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 && arr[j-1] > 0)
       
                    // number of subsequence using 1 to j-1
                    // terms and j-th term
                    dp[i][j] += dp[parseInt(i/arr[j - 1], 10)][j - 1] + 1;
            }
        }
        return dp[k][n];
    }
     
    let A = [1, 2, 3, 4];
    let k = 10;
    document.write(productSubSeqCount(A, k));
     
    // This code is contributed by suresh07.
</script>

Output: 
 

11

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.
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :