Given an integer array arr[] of size N and an integer K. The task is to find the length of the 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
Approach:
- The above problem can be solved using recursion.
- Choose the element at that position if the 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(solve(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++ program to find the Longest // Increasing Subsequence having sum // value atmost K #include <bits/stdc++.h> 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 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 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# 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 |
<script> // Javascript program to find the Longest // Increasing Subsequence having sum // value atmost K function solve(arr, N, prevele, i, 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 {
var 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 var N = 16;
var arr
= [0, 8, 4, 12,
2, 10, 6, 14,
1, 9, 5, 13,
3, 11, 7, 15];
var K = 40;
document.write( solve(arr, N, -1000000000, 0, K));
</script> |
5
Time Complexity: O (2N)
Auxiliary Space: O (1)