Count of subsequences in an array with sum less than or equal to X - GeeksforGeeks

09 Nov, 2021
Given an integer array arr[] of size N and an integer X, the task is to count the number of subsequences in that array such that its sum is less than or equal to X. Note: 1 <= N <= 1000 and 1 <= X <= 1000, where N is the size of the array.
Examples:  
Input : arr[] = {84, 87, 73}, X = 100 Output : 3 Explanation: The three subsequences with sum less than or equal to 100 are {84}, {87} and {73}.
Input : arr[] = {25, 13, 40}, X = 50 Output : 4 Explanation: The four subsequences with sum less than or equal to 50 are {25}, {13}, {40} and {25, 13}.  
Naive Approach: Generate all the subsequences of the array and check if the sum is less than or equal to X. Time complexity:O(2N)
Efficient Approach: Generate the count of subsequences using Dynamic Programming. In order to solve the problem, follow the steps below: 
For any index ind, if arr[ind] ≤ X then, the count of subsequences including as well as excluding the element at the current index:
countSubsequence(ind, X) = countSubsequence(ind + 1, X) (excluding) + countSubsequence(ind + 1, X – arr[ind]) (including)
Else, count subsequences excluding the current index:
countSubsequence(ind, X) = countSubsequence(ind + 1, X) (excluding)
Finally, subtract 1 from the final count returned by the function as it also counts an empty subsequence.
Below is the implementation of the above approach:  
C++
Java
C#
Javascript
// C++ Program to count number// of subsequences in an array// with sum less than or equal to X#include <bits/stdc++.h>using namespace std; // Utility function to return the count// of subsequence in an array with sum// less than or equal to Xint countSubsequenceUtil(    int ind, int sum,    int* A, int N,    vector<vector<int> >& dp){    // Base condition    if (ind == N)        return 1;     // Return if the sub-problem    // is already calculated    if (dp[ind][sum] != -1)        return dp[ind][sum];     // Check if the current element is    // less than or equal to sum    if (A[ind] <= sum) {        // Count subsequences excluding        // the current element        dp[ind][sum]            = countSubsequenceUtil(                  ind + 1,                  sum, A, N, dp)              +               // Count subsequences including              // the current element              countSubsequenceUtil(                  ind + 1,                  sum - A[ind],                  A, N, dp);    }     else {        // Exclude current element        dp[ind][sum]            = countSubsequenceUtil(                ind + 1,                sum, A,                N, dp);    }     // Return the result    return dp[ind][sum];} // Function to return the count of subsequence// in an array with sum less than or equal to Xint countSubsequence(int* A, int N, int X){    // Initialize a DP array    vector<vector<int> > dp(        N,        vector<int>(X + 1, -1));     // Return the result    return countSubsequenceUtil(0, X, A,                                N, dp)           - 1;} // Driver Codeint main(){    int arr[] = { 25, 13, 40 }, X = 50;     int N = sizeof(arr) / sizeof(arr[0]);     cout << countSubsequence(arr, N, X);     return 0;}
// Java program to count number// of subsequences in an array// with sum less than or equal to Xclass GFG{ // Utility function to return the count// of subsequence in an array with sum// less than or equal to Xstatic int countSubsequenceUtil(int ind, int sum,                                int []A, int N,                                int [][]dp){         // Base condition    if (ind == N)        return 1;     // Return if the sub-problem    // is already calculated    if (dp[ind][sum] != -1)        return dp[ind][sum];     // Check if the current element is    // less than or equal to sum    if (A[ind] <= sum)    {                 // Count subsequences excluding        // the current element        dp[ind][sum] = countSubsequenceUtil(                           ind + 1, sum,                           A, N, dp) +                                               // Count subsequences                       // including the current                       // element                       countSubsequenceUtil(                           ind + 1,                           sum - A[ind],                           A, N, dp);    }    else    {                 // Exclude current element        dp[ind][sum] = countSubsequenceUtil(                           ind + 1, sum,                           A, N, dp);    }     // Return the result    return dp[ind][sum];} // Function to return the count of subsequence// in an array with sum less than or equal to Xstatic int countSubsequence(int[] A, int N, int X){         // Initialize a DP array    int [][]dp = new int[N][X + 1];    for(int i = 0; i < N; i++)    {        for(int j = 0; j < X + 1; j++)        {            dp[i][j] = -1;        }    }         // Return the result    return countSubsequenceUtil(0, X, A,                                N, dp) - 1;} // Driver Codepublic static void main(String[] args){    int arr[] = { 25, 13, 40 }, X = 50;    int N = arr.length;     System.out.print(countSubsequence(arr, N, X));}} // This code is contributed by Rajput-Ji
// C# program to count number// of subsequences in an array// with sum less than or equal to Xusing System; class GFG{ // Utility function to return the count// of subsequence in an array with sum// less than or equal to Xstatic int countSubsequenceUtil(int ind, int sum,                                int []A, int N,                                int [,]dp){         // Base condition    if (ind == N)        return 1;     // Return if the sub-problem    // is already calculated    if (dp[ind, sum] != -1)        return dp[ind, sum];     // Check if the current element is    // less than or equal to sum    if (A[ind] <= sum)    {                 // Count subsequences excluding        // the current element        dp[ind, sum] = countSubsequenceUtil(                           ind + 1, sum,                           A, N, dp) +                                                   // Count subsequences                       // including the current                       // element                       countSubsequenceUtil(                           ind + 1,                           sum - A[ind],                           A, N, dp);    }    else    {                 // Exclude current element        dp[ind, sum] = countSubsequenceUtil(                           ind + 1, sum,                           A, N, dp);    }     // Return the result    return dp[ind, sum];} // Function to return the count of subsequence// in an array with sum less than or equal to Xstatic int countSubsequence(int[] A, int N, int X){         // Initialize a DP array    int [,]dp = new int[N, X + 1];    for(int i = 0; i < N; i++)    {        for(int j = 0; j < X + 1; j++)        {            dp[i, j] = -1;        }    }         // Return the result    return countSubsequenceUtil(0, X, A,                                N, dp) - 1;} // Driver Codepublic static void Main(String[] args){    int []arr = { 25, 13, 40 };    int X = 50;    int N = arr.Length;     Console.Write(countSubsequence(arr, N, X));}} // This code is contributed by 29AjayKumar
<script> // JavaScript program to count number// of subsequences in an array// with sum less than or equal to X // Utility function to return the count// of subsequence in an array with sum// less than or equal to Xfunction countSubsequenceUtil(ind, sum, A, N, dp){         // Base condition    if (ind == N)        return 1;     // Return if the sub-problem    // is already calculated    if (dp[ind][sum] != -1)        return dp[ind][sum];     // Check if the current element is    // less than or equal to sum    if (A[ind] <= sum)    {                 // Count subsequences excluding        // the current element        dp[ind][sum] = countSubsequenceUtil(                           ind + 1, sum,                           A, N, dp) +                                               // Count subsequences                       // including the current                       // element                       countSubsequenceUtil(                           ind + 1,                           sum - A[ind],                           A, N, dp);    }    else    {                 // Exclude current element        dp[ind][sum] = countSubsequenceUtil(                           ind + 1, sum,                           A, N, dp);    }     // Return the result    return dp[ind][sum];} // Function to return the count of subsequence// in an array with sum less than or equal to Xfunction countSubsequence(A, N, X){         // Initialize a DP array    let dp = new Array(N);    for(var i = 0; i < dp.length; i++)    {        dp[i] = new Array(2);    }     for(let i = 0; i < N; i++)    {        for(let j = 0; j < X + 1; j++)        {            dp[i][j] = -1;        }    }         // Return the result    return countSubsequenceUtil(0, X, A,                                N, dp) - 1;}   // Driver Codelet arr = [ 25, 13, 40 ], X = 50;let N = arr.length; document.write(countSubsequence(arr, N, X)); // This code is contributed by susmitakundugoaldanga </script>
4
 
Time Complexity: O(N*X)
Auxiliary Space: O(N*X) 
Rajput-Ji
29AjayKumar
susmitakundugoaldanga
rohitkumarsinghcna
subsequence
Arrays
Competitive Programming
Dynamic Programming
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Top 50 Array Coding Problems for Interviews
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Maximum and minimum of an array using minimum number of comparisons
Practice for cracking any coding interview
Arrow operator -> in C/C++ with Examples
Competitive Programming - A Complete Guide
Modulo 10^9+7 (1000000007)
Top 10 Algorithms and Data Structures for Competitive Programming