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

• Difficulty Level : Hard
• Last Updated : 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 :
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 :
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++

 // C++ Program to count number// of subsequences in an array// with sum less than or equal to X#include 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 >& 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 > dp(        N,        vector(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);     cout << countSubsequence(arr, N, X);     return 0;}

Java

 // 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#

 // 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

Javascript


Output:
4

Time Complexity: O(N*X)

Auxiliary Space: O(N*X)

My Personal Notes arrow_drop_up