Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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




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



<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 X
function 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 X
function 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 Code
let arr = [ 25, 13, 40 ], X = 50;
let N = arr.length;
 
document.write(countSubsequence(arr, N, X));
 
// This code is contributed by susmitakundugoaldanga
 
</script>
Output: 
4
 
Time Complexity: O(N*X)
Auxiliary Space: O(N*X)
 

My Personal Notes
arrow_drop_up
Next

Find all subsequences with sum equals to K
Recommended Articles
Page :
Count of subsequences with sum two less than the array sum
04, Nov 21
Count all subsequences having product less than K
05, Oct 17
Maximum sum subarray having sum less than or equal to given sum using Set
22, Apr 20
Maximum sum subarray having sum less than or equal to given sum
05, Aug 17
Largest number less than N with digit sum greater than the digit sum of N
04, Dec 18
For each element in 1st array count elements less than or equal to it in 2nd array | Set 2
01, Oct 18
Count array elements whose highest power of 2 less than or equal to that number is present in the given array
17, Jun 21
For each element in 1st array count elements less than or equal to it in 2nd array
11, Jun 17
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
17, Apr 19
Sum of all array elements less than X and greater than Y for Q queries
18, Jun 20
Largest subset having with sum less than equal to sum of respective indices
14, Jul 20
Count elements less than or equal to a given value in a sorted rotated array
15, Jun 17
Count the number of strings in an array whose distinct characters are less than equal to M
06, May 20
Count of subsets with sum one less than the sum of Array
11, Nov 21
Find maximum sum array of length less than or equal to m
03, May 18
Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
18, Feb 19
Count sub-arrays which have elements less than or equal to X
17, Nov 17
Count number of integers less than or equal to N which has exactly 9 divisors
31, Oct 18
Count of Multiples of A ,B or C less than or equal to N
24, Sep 19
Count numbers whose maximum sum of distinct digit-sum is less than or equals M
30, Mar 20
Minimum value of X such that sum of arr[i] - X raised to the power of brr[i] is less than or equal to K
23, Jul 21
Split array into two subsequences having minimum count of pairs with sum equal to X
09, Oct 20
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Split an array into equal length subsequences consisting of equal elements only
13, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rupesh_rao
@rupesh_rao
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!