# Longest Increasing Subsequence having sum value atmost K

Given an integer array arr[] of size N and an integer K. The task is to find length of longest subsequence whose sum is less than or equal to K.

Example:

Input: arr[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15} K = 40
Output: 5
Explanation:
If we select subsequence {0, 1, 3, 7, 15} then total sum will be 26, which is less than 40. Hence, the longest increasing possible subsequence length is 5.

Input: arr[] = {5, 8, 3, 7, 9, 1} K = 4
Output: 1

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. The above problem can be solve using recursion.
• At any position in the array, there are two choices:

• Choose the element at that position if total sum is less than K and explore the rest items.
• Leave the element at that position and explore the rest.

Recurrence relation will be given as:

Recurrence relation:
T(N) = max(sove(arr, N, arr[i], i+1, K-arr[i])+1, solve(arr, N, prevele, i+1, K));
Base conditions:
if(i >= N || K <= 0)
return 0

Here is the implementation of the above approach:

## C++

 `// C++ program to find the Longest ` `// Increasing Subsequence having sum ` `// value atmost K ` `#include ` `using` `namespace` `std; ` ` `  `int` `solve(``int` `arr[], ``int` `N, ` `          ``int` `prevele, ``int` `i, ``int` `K) ` `{ ` `    ``// check for base cases ` `    ``if` `(i >= N || K <= 0) ` `        ``return` `0; ` ` `  `    ``// check if it is possible to take ` `    ``// current elements ` `    ``if` `(arr[i] <= prevele ` `        ``|| (K - arr[i] < 0)) { ` ` `  `        ``return` `solve(arr, N, prevele, ` `                     ``i + 1, K); ` `    ``} ` ` `  `    ``// if current element is ignored ` `    ``else` `{ ` `        ``int` `ans = max( ` `            ``solve(arr, N, arr[i], ` `                  ``i + 1, K - arr[i]) ` `                ``+ 1, ` `            ``solve(arr, N, prevele, ` `                  ``i + 1, K)); ` `        ``return` `ans; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 16; ` `    ``int` `arr[N] ` `        ``= { 0, 8, 4, 12, ` `            ``2, 10, 6, 14, ` `            ``1, 9, 5, 13, ` `            ``3, 11, 7, 15 }; ` `    ``int` `K = 40; ` ` `  `    ``cout << solve(arr, N, ` `                  ``INT_MIN, 0, K) ` `         ``<< endl; ` `} `

## Java

 `// Java program to find the Longest  ` `// Increasing Subsequence having sum  ` `// value atmost K  ` `import` `java.io.*;  ` ` `  `class` `GFG{  ` `     `  `static` `int` `solve(``int` `arr[], ``int` `N, ` `                 ``int` `prevele, ``int` `i, ``int` `K) ` `{ ` `     `  `    ``// Check for base cases ` `    ``if` `(i >= N || K <= ``0``) ` `        ``return` `0``; ` ` `  `    ``// Check if it is possible to take ` `    ``// current elements ` `    ``if` `(arr[i] <= prevele || ` `       ``(K - arr[i] < ``0``)) ` `    ``{ ` `        ``return` `solve(arr, N, prevele, ` `                     ``i + ``1``, K); ` `    ``} ` ` `  `    ``// If current element is ignored ` `    ``else` `    ``{ ` `        ``int` `ans = Math.max(solve(arr, N, arr[i], ` `                              ``i + ``1``, K - arr[i]) + ``1``, ` `                           ``solve(arr, N, prevele, ` `                                 ``i + ``1``, K)); ` `                                  `  `        ``return` `ans; ` `    ``} ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main (String[] args)  ` `{  ` `    ``int` `N = ``16``; ` `    ``int` `arr[] = ``new` `int``[]{ ``0``, ``8``, ``4``, ``12``, ` `                           ``2``, ``10``, ``6``, ``14``, ` `                           ``1``, ``9``, ``5``, ``13``, ` `                           ``3``, ``11``, ``7``, ``15` `}; ` `    ``int` `K = ``40``; ` ` `  `    ``System.out.print(solve(arr, N, ` `          ``Integer.MIN_VALUE, ``0``, K));  ` `}  ` `}  ` ` `  `// This code is contributed by Pratima Pandey `

## Python3

 `# Python3 program to find the Longest ` `# Increasing Subsequence having sum ` `# value atmost K ` `import` `sys ` ` `  `def` `solve(arr, N, prevele, i, K): ` `     `  `    ``# Check for base cases ` `    ``if` `(i >``=` `N ``or` `K <``=` `0``): ` `        ``return` `0``; ` ` `  `    ``# Check if it is possible to take ` `    ``# current elements ` `    ``if` `(arr[i] <``=` `prevele ``or`  `       ``(K ``-` `arr[i] < ``0``)): ` `        ``return` `solve(arr, N, prevele, ` `                     ``i ``+` `1``, K); ` ` `  `    ``# If current element is ignored ` `    ``else``: ` `        ``ans ``=` `max``(solve(arr, N, arr[i], ` `                     ``i ``+` `1``, K ``-` `arr[i]) ``+` `1``, ` `                  ``solve(arr, N, prevele,  ` `                        ``i ``+` `1``, K)); ` ` `  `        ``return` `ans; ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``N ``=` `16``; ` `    ``arr ``=` `[ ``0``, ``8``, ``4``, ``12``, ` `            ``2``, ``10``, ``6``, ``14``, ` `            ``1``, ``9``, ``5``, ``13``, ` `            ``3``, ``11``, ``7``, ``15` `]; ` `    ``K ``=` `40``; ` ` `  `    ``print``(solve(arr, N, ``-``sys.maxsize, ``0``, K)); ` ` `  `# This code is contributed by 29AjayKumar `

## C#

 `// C# program to find the Longest  ` `// Increasing Subsequence having sum  ` `// value atmost K  ` `using` `System;  ` ` `  `class` `GFG{  ` `     `  `static` `int` `solve(``int``[] arr, ``int` `N, ` `                 ``int` `prevele, ``int` `i, ``int` `K) ` `{ ` `     `  `    ``// Check for base cases ` `    ``if` `(i >= N || K <= 0) ` `        ``return` `0; ` ` `  `    ``// Check if it is possible to take ` `    ``// current elements ` `    ``if` `(arr[i] <= prevele || ` `       ``(K - arr[i] < 0)) ` `    ``{ ` `        ``return` `solve(arr, N, prevele, ` `                     ``i + 1, K); ` `    ``} ` ` `  `    ``// If current element is ignored ` `    ``else` `    ``{ ` `        ``int` `ans = Math.Max(solve(arr, N, arr[i], ` `                                 ``i + 1, K - arr[i]) + 1, ` `                           ``solve(arr, N, prevele, ` `                                 ``i + 1, K)); ` `                                 `  `        ``return` `ans; ` `    ``} ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main ()  ` `{  ` `    ``int` `N = 16; ` `    ``int``[] arr = ``new` `int``[]{ 0, 8, 4, 12, ` `                           ``2, 10, 6, 14, ` `                           ``1, 9, 5, 13, ` `                           ``3, 11, 7, 15 }; ` `    ``int` `K = 40; ` ` `  `    ``Console.Write(solve(arr, N, ` `        ``Int32.MinValue, 0, K));  ` `}  ` `} ` ` `  `// This code is contributed by sanjoy_62 `

Output:

```5
```

Time Complexity: O (2N)
Auxiliary Space: O (1)

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.

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.