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

• Difficulty Level : Hard
• Last Updated : 22 Jun, 2022

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 X``int` `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 X``int` `countSubsequence(``int``* A, ``int` `N, ``int` `X)``{``    ``// Initialize a DP array``    ``vector > 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

 ``

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