# Maximum size subset with given sum using Backtracking

Given an array arr[] consisting of N integers and an integer K, the task is to find the length of longest subsequence with sum equal to K.
Examples:

Input: arr[] = {-4, -2, -2, -1, 6}, K = 0
Output:
Explanation:
The longest subsequence is of length 3 which is {-4, -2, 6} having sum 0.
Input: arr[] = {-3, 0, 1, 1, 2}, K = 1
Output:
Explanation: The longest subsequence is of length 5 which is {-3, 0, 1, 1, 2} having sum 1.

Naive Approach: The simplest approach to solve the problem is to generate all the possible subsequences of different lengths and check if their sum is equal to K. Out of all these subsequences with sum K, find the subsequence with longest length.
Time complexity: O(2N)
Recursive & Backtracking Approach: The basic approach of this problem is to sort the vector and find the sum of all the possible subsequences and pick up the subsequence with the maximum length having the given sum. This can be done using Recursion and Backtracking.
Follow the steps below to solve this problem:

• Sort the given array/vector.
• Initialize a global variable max_length to 0, which stores the maximum length subset.
• For every index i in the array, call the recursion function to find out all the possible subsets with elements in the range [i, N-1] having sum K.
• Everytime a subset with sum K is found, check if its size is greater than the current max_length value. If yes, then update the value of max_length.
• After all the possible subset sums are computed, return the max_length.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the ` `// above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Initialise maximum possible ` `// length of subsequence ` `int` `max_length = 0; ` ` `  `// Store elements to compare ` `// max_length with its size ` `// and change the value of ` `// max_length accordingly ` `vector<``int``> store; ` ` `  `// Store the elements of the ` `// longest subsequence ` `vector<``int``> ans; ` ` `  `// Function to find the length ` `// of longest subsequence ` `void` `find_max_length( ` `    ``vector<``int``>& arr, ` `    ``int` `index, ``int` `sum, ``int` `k) ` `{ ` `    ``sum = sum + arr[index]; ` `    ``store.push_back(arr[index]); ` `    ``if` `(sum == k) { ` `        ``if` `(max_length < store.size()) { ` `            ``// Update max_length ` `            ``max_length = store.size(); ` ` `  `            ``// Store the subsequence ` `            ``// elements ` `            ``ans = store; ` `        ``} ` `    ``} ` ` `  `    ``for` `(``int` `i = index + 1; ` `         ``i < arr.size(); i++) { ` `        ``if` `(sum + arr[i] <= k) { ` ` `  `            ``// Recursively proceed ` `            ``// with obtained sum ` `            ``find_max_length(arr, i, ` `                            ``sum, k); ` ` `  `            ``// poping elements ` `            ``// from back ` `            ``// of vector store ` `            ``store.pop_back(); ` `        ``} ` ` `  `        ``// if sum > 0 then we don't ` `        ``// required thatsubsequence ` `        ``// so return and continue ` `        ``// with earlier elements ` `        ``else` `            ``return``; ` `    ``} ` ` `  `    ``return``; ` `} ` ` `  `int` `longestSubsequence(vector<``int``> arr, ` `                       ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Sort the given array ` `    ``sort(arr.begin(), arr.end()); ` ` `  `    ``// Traverse the array ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``// If max_length is already ` `        ``// greater than or equal ` `        ``// than remaining length ` `        ``if` `(max_length >= n - i) ` `            ``break``; ` ` `  `        ``store.clear(); ` ` `  `        ``find_max_length(arr, i, 0, k); ` `    ``} ` ` `  `    ``return` `max_length; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``vector<``int``> arr{ -3, 0, 1, 1, 2 }; ` `    ``int` `n = arr.size(); ` `    ``int` `k = 1; ` ` `  `    ``cout << longestSubsequence(arr, ` `                               ``n, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java Program to implement the ` `// above approach ` `import` `java.util.*; ` `class` `GFG{ ` `  `  `// Initialise maximum possible ` `// length of subsequence ` `static` `int` `max_length = ``0``; ` `  `  `// Store elements to compare ` `// max_length with its size ` `// and change the value of ` `// max_length accordingly ` `static` `Vector store = ``new` `Vector(); ` `  `  `// Store the elements of the ` `// longest subsequence ` `static` `Vector ans = ``new` `Vector(); ` `  `  `// Function to find the length ` `// of longest subsequence ` `static` `void` `find_max_length( ` `    ``int` `[]arr, ` `    ``int` `index, ``int` `sum, ``int` `k) ` `{ ` `    ``sum = sum + arr[index]; ` `    ``store.add(arr[index]); ` `    ``if` `(sum == k)  ` `    ``{ ` `        ``if` `(max_length < store.size())  ` `        ``{ ` `            ``// Update max_length ` `            ``max_length = store.size(); ` `  `  `            ``// Store the subsequence ` `            ``// elements ` `            ``ans = store; ` `        ``} ` `    ``} ` `  `  `    ``for` `(``int` `i = index + ``1``; ` `             ``i < arr.length; i++)  ` `    ``{ ` `        ``if` `(sum + arr[i] <= k)  ` `        ``{ ` `  `  `            ``// Recursively proceed ` `            ``// with obtained sum ` `            ``find_max_length(arr, i, ` `                            ``sum, k); ` `  `  `            ``// poping elements ` `            ``// from back ` `            ``// of vector store ` `            ``store.remove(store.size() - ``1``); ` `        ``} ` `  `  `        ``// if sum > 0 then we don't ` `        ``// required thatsubsequence ` `        ``// so return and continue ` `        ``// with earlier elements ` `        ``else` `            ``return``; ` `    ``} ` `    ``return``; ` `} ` `  `  `static` `int` `longestSubsequence(``int` `[]arr, ` `                                 ``int` `n, ``int` `k) ` `{ ` `  `  `    ``// Sort the given array ` `    ``Arrays.sort(arr); ` `  `  `    ``// Traverse the array ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``// If max_length is already ` `        ``// greater than or equal ` `        ``// than remaining length ` `        ``if` `(max_length >= n - i) ` `            ``break``; ` `  `  `        ``store.clear(); ` `  `  `        ``find_max_length(arr, i, ``0``, k); ` `    ``} ` `    ``return` `max_length; ` `} ` `  `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `[]arr = { -``3``, ``0``, ``1``, ``1``, ``2` `}; ` `    ``int` `n = arr.length; ` `    ``int` `k = ``1``; ` `  `  `    ``System.out.print(longestSubsequence(arr, ` `                                           ``n, k)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh`

## C#

 `// C# program to implement the ` `// above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Initialise maximum possible ` `// length of subsequence ` `static` `int` `max_length = 0; ` ` `  `// Store elements to compare ` `// max_length with its size ` `// and change the value of ` `// max_length accordingly ` `static` `List<``int``> store = ``new` `List<``int``>(); ` ` `  `// Store the elements of the ` `// longest subsequence ` `static` `List<``int``> ans = ``new` `List<``int``>(); ` ` `  `// Function to find the length ` `// of longest subsequence ` `static` `void` `find_max_length(``int` `[]arr, ` `                            ``int` `index,  ` `                            ``int` `sum, ``int` `k) ` `{ ` `    ``sum = sum + arr[index]; ` `    ``store.Add(arr[index]); ` `     `  `    ``if` `(sum == k)  ` `    ``{ ` `        ``if` `(max_length < store.Count)  ` `        ``{ ` `             `  `            ``// Update max_length ` `            ``max_length = store.Count; ` ` `  `            ``// Store the subsequence ` `            ``// elements ` `            ``ans = store; ` `        ``} ` `    ``} ` ` `  `    ``for``(``int` `i = index + 1; ` `            ``i < arr.Length; i++)  ` `    ``{ ` `        ``if` `(sum + arr[i] <= k)  ` `        ``{ ` ` `  `            ``// Recursively proceed ` `            ``// with obtained sum ` `            ``find_max_length(arr, i, ` `                            ``sum, k); ` ` `  `            ``// poping elements ` `            ``// from back ` `            ``// of vector store ` `            ``store.RemoveAt(store.Count - 1); ` `        ``} ` ` `  `        ``// If sum > 0 then we don't ` `        ``// required thatsubsequence ` `        ``// so return and continue ` `        ``// with earlier elements ` `        ``else` `            ``return``; ` `    ``} ` `    ``return``; ` `} ` ` `  `static` `int` `longestSubsequence(``int` `[]arr, ` `                              ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Sort the given array ` `    ``Array.Sort(arr); ` ` `  `    ``// Traverse the array ` `    ``for``(``int` `i = 0; i < n; i++)  ` `    ``{ ` `         `  `        ``// If max_length is already ` `        ``// greater than or equal ` `        ``// than remaining length ` `        ``if` `(max_length >= n - i) ` `            ``break``; ` ` `  `        ``store.Clear(); ` ` `  `        ``find_max_length(arr, i, 0, k); ` `    ``} ` `    ``return` `max_length; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { -3, 0, 1, 1, 2 }; ` `    ``int` `n = arr.Length; ` `    ``int` `k = 1; ` ` `  `    ``Console.Write(longestSubsequence(arr, ` `                                     ``n, k)); ` `} ` `} ` ` `  `// This code is contributed by gauravrajput1  `

Output:

```5
```

Time Complexity: O(N3
Auxiliary Space: O(N)
Dynamic Programming Approach: Refer to this article for a further optimized approach to solve the problem.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.