Skip to content
Related Articles

Related Articles

Count of subsequences in an array with sum less than or equal to X
  • Difficulty Level : Hard
  • Last Updated : 05 Aug, 2020

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 <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;
}

Java




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

C#




// C# program to count number
// of subsequences in an array
// with sum less than or equal to X
using System;
  
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 };
    int X = 50;
    int N = arr.Length;
  
    Console.Write(countSubsequence(arr, N, X));
}
}
  
// This code is contributed by 29AjayKumar
Output: 
4

Time Complexity: O(N*X)
 

competitive-programming-img

My Personal Notes arrow_drop_up
Recommended Articles
Page :