Given a set of n integers where n <= 40. Each of them is at most 10^{12}, determine the maximum sum subset having sum less than or equal S where S <= 10^{18}.

**Example:**

Input : set[] = {45, 34, 4, 12, 5, 2} and S = 42 Output : 41 Maximum possible subset sum is 41 which can be obtained by summing 34, 5 and 2. Input : Set[] = {3, 34, 4, 12, 5, 2} and S = 10 Output : 10 Maximum possible subset sum is 10 which can be obtained by summing 2, 3 and 5.

A Brute Force approach to solve this problem would be find all possible subset sums of N integers and check if it is less than or equal S and keep track of such a subset with maximum sum. The time complexity using this approach would be O(2^{n}) and n is at most 40. 2^{40} will be quite large and hence we need to find more optimal approach.

**Meet in the middle** is a search technique which is used when the input is small but not as small that brute force can be used. Like divide and conquer it splits the problem into two, solves them individually and then merge them. But we can’t apply meet in the middle like divide and conquer because we don’t have the same structure as the original problem.

- Split the set of integers into 2 subsets say A and B. A having first n/2 integers and B having rest.
- Find all possible subset sums of integers in set A and store in an array X. Similarly calculate all possible subset sums of integers in set B and store in array Y. Hence, Size of each of the array X and Y will be at most 2
^{n/2}. - Now merge these 2 subproblems. Find combinations from array X and Y such that their sum is less than or equal to S.
- One way to do that is simply iterate over all elements of array Y for each element of array X to check the existence of such a combination. This will take O( (2
^{n/2})^{2}) which is equivalent to O(2^{n}). - To make it less complex, first sort array Y and then iterate over each element of X and for each element x in X use binary search to find maximum element y in Y such that x + y <= S.
- Binary search here helps in reducing complexity from 2
^{n}to 2^{n/2}log(2^{n/2})which is equivalent to 2^{n/2}n. - Thus our final running time is O(2
^{n/2}n).

- One way to do that is simply iterate over all elements of array Y for each element of array X to check the existence of such a combination. This will take O( (2

## C++

`// C++ program to demonstrate working of Meet in the` `// Middle algorithm for maximum subset sum problem.` `#include <bits/stdc++.h>` `using` `namespace` `std;` `typedef` `long` `long` `int` `ll;` `ll X[2000005],Y[2000005];` `// Find all possible sum of elements of a[] and store` `// in x[]` `void` `calcsubarray(ll a[], ll x[], ` `int` `n, ` `int` `c)` `{` ` ` `for` `(` `int` `i=0; i<(1<<n); i++)` ` ` `{` ` ` `ll s = 0;` ` ` `for` `(` `int` `j=0; j<n; j++)` ` ` `if` `(i & (1<<j))` ` ` `s += a[j+c];` ` ` `x[i] = s;` ` ` `}` `}` `// Returns the maximum possible sum less or equal to S` `ll solveSubsetSum(ll a[], ` `int` `n, ll S)` `{` ` ` `// Compute all subset sums of first and second` ` ` `// halves` ` ` `calcsubarray(a, X, n/2, 0);` ` ` `calcsubarray(a, Y, n-n/2, n/2);` ` ` `int` `size_X = 1<<(n/2);` ` ` `int` `size_Y = 1<<(n-n/2);` ` ` `// Sort Y (we need to do doing binary search in it)` ` ` `sort(Y, Y+size_Y);` ` ` `// To keep track of the maximum sum of a subset` ` ` `// such that the maximum sum is less than S` ` ` `ll max = 0;` ` ` `// Traverse all elements of X and do Binary Search` ` ` `// for a pair in Y with maximum sum less than S.` ` ` `for` `(` `int` `i=0; i<size_X; i++)` ` ` `{` ` ` `if` `(X[i] <= S)` ` ` `{` ` ` `// lower_bound() returns the first address` ` ` `// which has value greater than or equal to` ` ` `// S-X[i].` ` ` `int` `p = lower_bound(Y, Y+size_Y, S-X[i]) - Y;` ` ` `// If S-X[i] was not in array Y then decrease` ` ` `// p by 1` ` ` `if` `(p == size_Y || Y[p] != (S-X[i]))` ` ` `p--;` ` ` `if` `((Y[p]+X[i]) > max)` ` ` `max = Y[p]+X[i];` ` ` `}` ` ` `}` ` ` `return` `max;` `}` `// Driver code` `int` `main()` `{` ` ` `ll a[] = {3, 34, 4, 12, 5, 2};` ` ` `int` `n=` `sizeof` `(a)/` `sizeof` `(a[0]);` ` ` `ll S = 10;` ` ` `printf` `(` `"Largest value smaller than or equal to given "` ` ` `"sum is %lld\n"` `, solveSubsetSum(a,n,S));` ` ` `return` `0;` `}` |

## Java

`// Java program to demonstrate working of` `// Meet in the Middle algorithm for` `// maximum subset sum problem` `import` `java.util.*;` `import` `java.lang.*;` `import` `java.io.*;` `class` `GFG{` ` ` `static` `long` `X[] = ` `new` `long` `[` `2000005` `];` `static` `long` `Y[] = ` `new` `long` `[` `2000005` `];` ` ` `// Find all possible sum of elements of a[]` `// and store in x[]` `static` `void` `calcsubarray(` `long` `a[],` `long` `x[],` ` ` `int` `n, ` `int` `c)` `{` ` ` `for` `(` `int` `i = ` `0` `; i < (` `1` `<< n); i++)` ` ` `{` ` ` `long` `s = ` `0` `;` ` ` `for` `(` `int` `j = ` `0` `; j < n; j++)` ` ` `if` `((i & (` `1` `<< j)) == ` `0` `)` ` ` `s += a[j + c];` ` ` ` ` `x[i] = s;` ` ` `}` `}` `// Returns the maximum possible sum` `// less or equal to S ` `static` `long` `solveSubsetSum(` `long` `a[], ` `int` `n, ` `long` `S)` `{` ` ` ` ` `// Compute all subset sums of first and second` ` ` `// halves` ` ` `calcsubarray(a, X, n / ` `2` `, ` `0` `);` ` ` `calcsubarray(a, Y, n - n / ` `2` `, n / ` `2` `);` ` ` ` ` `int` `size_X = ` `1` `<< (n / ` `2` `);` ` ` `int` `size_Y = ` `1` `<< (n - n / ` `2` `);` ` ` ` ` `// Sort Y (we need to do doing` ` ` `// binary search in it)` ` ` `Arrays.sort(Y);` ` ` ` ` `// To keep track of the maximum sum` ` ` `// of a subset such that the maximum` ` ` `// sum is less than S` ` ` `long` `max = ` `0` `;` ` ` ` ` `// Traverse all elements of X and do` ` ` `// Binary Search for a pair in Y with` ` ` `// maximum sum less than S.` ` ` `for` `(` `int` `i = ` `0` `; i < size_X; i++)` ` ` `{` ` ` `if` `(X[i] <= S)` ` ` `{` ` ` ` ` `// lower_bound() returns the first address` ` ` `// which has value greater than or equal to` ` ` `// S-X[i].` ` ` `int` `p = lower_bound(Y, S - X[i]);` ` ` ` ` `// If S-X[i] was not in array Y then` ` ` `// decrease p by 1` ` ` `if` `(p == size_Y || Y[p] != (S - X[i]))` ` ` `p--;` ` ` ` ` `if` `((Y[p] + X[i]) > max)` ` ` `max = Y[p] + X[i];` ` ` `}` ` ` `}` ` ` `return` `max;` `}` `static` `int` `lower_bound(` `long` `a[], ` `long` `x)` `{` ` ` ` ` `// x is the target value or key` ` ` `int` `l = -` `1` `, r = a.length;` ` ` `while` `(l + ` `1` `< r)` ` ` `{` ` ` `int` `m = (l + r) >>> ` `1` `;` ` ` `if` `(a[m] >= x)` ` ` `r = m;` ` ` `else` ` ` `l = m;` ` ` `}` ` ` `return` `r;` `}` `// Driver code` `public` `static` `void` `main (String[] args)` `{` ` ` `long` `a[] = { ` `3` `, ` `34` `, ` `4` `, ` `12` `, ` `5` `, ` `2` `};` ` ` `int` `n = a.length;` ` ` `long` `S = ` `10` `;` ` ` `System.out.println(` `"Largest value smaller "` `+` ` ` `"than or equal to given "` `+` ` ` `"sum is "` `+` ` ` `solveSubsetSum(a, n, S));` `}` `}` `// This code is contributed by jyoti369` |

## Python3

`# Python program to demonstrate working of Meet in the` `# Middle algorithm for maximum subset sum problem.` `from` `typing ` `import` `List` `import` `bisect` `X ` `=` `[` `0` `] ` `*` `2000005` `Y ` `=` `[` `0` `] ` `*` `2000005` `# Find all possible sum of elements of a[] and store` `# in x[]` `def` `calcsubarray(a: ` `List` `[` `int` `], x: ` `List` `[` `int` `], n: ` `int` `, c: ` `int` `) ` `-` `> ` `None` `:` ` ` `for` `i ` `in` `range` `((` `1` `<< n)):` ` ` `s ` `=` `0` ` ` `for` `j ` `in` `range` `(n):` ` ` `if` `(i & (` `1` `<< j)):` ` ` `s ` `+` `=` `a[j ` `+` `c]` ` ` `x[i] ` `=` `s` `# Returns the maximum possible sum less or equal to S` `def` `solveSubsetSum(a: ` `List` `[` `int` `], n: ` `int` `, S: ` `int` `) ` `-` `> ` `int` `:` ` ` `global` `Y` ` ` ` ` `# Compute all subset sums of first and second` ` ` `# halves` ` ` `calcsubarray(a, X, n ` `/` `/` `2` `, ` `0` `)` ` ` `calcsubarray(a, Y, n ` `-` `n ` `/` `/` `2` `, n ` `/` `/` `2` `)` ` ` `size_X ` `=` `1` `<< (n ` `/` `/` `2` `)` ` ` `size_Y ` `=` `1` `<< (n ` `-` `n ` `/` `/` `2` `)` ` ` `# Sort Y (we need to do doing binary search in it)` ` ` `YY ` `=` `Y[:size_Y]` ` ` `YY.sort()` ` ` `Y ` `=` `YY` ` ` `# To keep track of the maximum sum of a subset` ` ` `# such that the maximum sum is less than S` ` ` `maxx ` `=` `0` ` ` `# Traverse all elements of X and do Binary Search` ` ` `# for a pair in Y with maximum sum less than S.` ` ` `for` `i ` `in` `range` `(size_X):` ` ` `if` `(X[i] <` `=` `S):` ` ` `# lower_bound() returns the first address` ` ` `# which has value greater than or equal to` ` ` `# S-X[i].` ` ` `p ` `=` `bisect.bisect_left(Y, S ` `-` `X[i])` ` ` `# If S-X[i] was not in array Y then decrease` ` ` `# p by 1` ` ` `if` `(p ` `=` `=` `size_Y ` `or` `(p < size_Y ` `and` `Y[p] !` `=` `(S ` `-` `X[i]))):` ` ` `p ` `-` `=` `1` ` ` `if` `((Y[p] ` `+` `X[i]) > maxx):` ` ` `maxx ` `=` `Y[p] ` `+` `X[i]` ` ` `return` `maxx` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `a ` `=` `[` `3` `, ` `34` `, ` `4` `, ` `12` `, ` `5` `, ` `2` `]` ` ` `n ` `=` `len` `(a)` ` ` `S ` `=` `10` ` ` `print` `(` `"Largest value smaller than or equal to given sum is {}"` `.` `format` `(` ` ` `solveSubsetSum(a, n, S)))` `# This code is contributed by sanjeev2552` |

## C#

`// C# program to demonstrate working of` `// Meet in the Middle algorithm for` `// maximum subset sum problem` `using` `System;` `public` `class` `GFG` `{` ` ` `static` `long` `[] X = ` `new` `long` `[2000005];` ` ` `static` `long` `[] Y = ` `new` `long` `[2000005];` ` ` `// Find all possible sum of elements of a[]` ` ` `// and store in x[]` ` ` `static` `void` `calcsubarray(` `long` `[] a,` `long` `[] x,` ` ` `int` `n, ` `int` `c)` ` ` `{` ` ` `for` `(` `int` `i = 0; i < (1 << n); i++)` ` ` `{` ` ` `long` `s = 0;` ` ` `for` `(` `int` `j = 0; j < n; j++)` ` ` `if` `((i & (1 << j)) == 0)` ` ` `s += a[j + c]; ` ` ` `x[i] = s;` ` ` `}` ` ` `}` ` ` `// Returns the maximum possible sum` ` ` `// less or equal to S ` ` ` `static` `long` `solveSubsetSum(` `long` `[] a, ` `int` `n, ` `long` `S)` ` ` `{` ` ` `// Compute all subset sums of first and second` ` ` `// halves` ` ` `calcsubarray(a, X, n / 2, 0);` ` ` `calcsubarray(a, Y, n - n / 2, n / 2);` ` ` `int` `size_X = 1 << (n / 2);` ` ` `int` `size_Y = 1 << (n - n / 2);` ` ` `// Sort Y (we need to do doing` ` ` `// binary search in it)` ` ` `Array.Sort(Y);` ` ` `// To keep track of the maximum sum` ` ` `// of a subset such that the maximum` ` ` `// sum is less than S` ` ` `long` `max = 0;` ` ` `// Traverse all elements of X and do` ` ` `// Binary Search for a pair in Y with` ` ` `// maximum sum less than S.` ` ` `for` `(` `int` `i = 0; i < size_X; i++)` ` ` `{` ` ` `if` `(X[i] <= S)` ` ` `{` ` ` `// lower_bound() returns the first address` ` ` `// which has value greater than or equal to` ` ` `// S-X[i].` ` ` `int` `p = lower_bound(Y, S - X[i]);` ` ` `// If S-X[i] was not in array Y then` ` ` `// decrease p by 1` ` ` `if` `(p == size_Y || Y[p] != (S - X[i]))` ` ` `p--;` ` ` `if` `((Y[p] + X[i]) > max)` ` ` `max = Y[p] + X[i];` ` ` `}` ` ` `}` ` ` `return` `max;` ` ` `}` ` ` `static` `int` `lower_bound(` `long` `[] a, ` `long` `x)` ` ` `{` ` ` `// x is the target value or key` ` ` `int` `l = -1, r = a.Length;` ` ` `while` `(l + 1 < r)` ` ` `{` ` ` `int` `m = (l + r) >> 1;` ` ` `if` `(a[m] >= x)` ` ` `r = m;` ` ` `else` ` ` `l = m;` ` ` `}` ` ` `return` `r;` ` ` `}` ` ` `// Driver code` ` ` `static` `public` `void` `Main ()` ` ` `{` ` ` `long` `[] a = { 3, 34, 4, 12, 5, 2 };` ` ` `int` `n = a.Length;` ` ` `long` `S = 10;` ` ` `Console.WriteLine(` `"Largest value smaller "` `+` ` ` `"than or equal to given "` `+` ` ` `"sum is "` `+` ` ` `solveSubsetSum(a, n, S));` ` ` `}` `}` `// This code is contributed by Dharanendra L V.` |

**Output:**

Largest value smaller than or equal to given sum is 10

**Reference: **

This article is contributed by **Madhur Modi**. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**