Skip to content
Related Articles
Open in App
Not now

Related Articles

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

Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 22 Jun, 2022
Improve Article
Save Article
Like Article

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

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>

Python3




# Python program for the above approach:
 
## Utility function to return the count
## of subsequence in an array with sum
## less than or equal to X
def countSubsequenceUtil(ind, s, A, N, dp):
 
    ## Base condition
    if (ind == N):
        return 1
 
    ## Return if the sub-problem
    ## is already calculated
    if (dp[ind][s] != -1):
        return dp[ind][s]
 
    ## Check if the current element is
    ## less than or equal to sum
    if (A[ind] <= s):
         
        ## Count subsequences excluding
        ## the current element
        ## Also, Count subsequences including
        ## the current element
        dp[ind][s] = countSubsequenceUtil(ind + 1, s, A, N, dp) + countSubsequenceUtil(ind + 1, s - A[ind], A, N, dp)
 
             
 
    else:
        ## Exclude current element
        dp[ind][s] = countSubsequenceUtil(ind + 1, s, A, N, dp)
 
    ## Return the result
    return dp[ind][s]
 
## Function to return the count of subsequence
## in an array with sum less than or equal to X
def countSubsequence(A, N, X):
 
    ## Initialize a DP array
    dp = [[-1 for _ in range(X + 1)] for i in range(N)]
 
    ## Return the result
    return countSubsequenceUtil(0, X, A, N, dp) - 1
 
 
## Driver code
if __name__=='__main__':
 
    arr = [25, 13, 40]
    X = 50
 
    N = len(arr)
 
    print(countSubsequence(arr, N, X))

Output: 

4

 

Time Complexity: O(N*X)

Auxiliary Space: O(N*X)
 


My Personal Notes arrow_drop_up
Like Article
Save Article
Related Articles

Start Your Coding Journey Now!