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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 X
int 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 X
int 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 Code
int main()
{
    int arr[] = { 25, 13, 40 }, X = 50;
  
    int N = sizeof(arr) / sizeof(arr[0]);
  
    cout << countSubsequence(arr, N, X);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count number
// of subsequences in an array
// with sum less than or equal to X
class GFG{
  
// Utility function to return the count
// of subsequence in an array with sum
// less than or equal to X
static 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 X
static 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 Code
public 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

chevron_right


Output:

4


Time Complexity: O(N*X)

competitive-programming-img




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.



Improved By : Rajput-Ji