GFG App
Open App
Browser
Continue

# Sum of subsets nearest to K possible from two given arrays

Given two arrays A[] and B[] consisting of N and M integers respectively, and an integer K, the task is to find the sum nearest to K possible by selecting exactly one element from the array A[] and an element from the array B[], at most twice.

Examples:

Input: A[] = {1, 7}, B[] = {3, 4}, K = 10
Output: 10
Explanation:
Sum obtained by selecting A[0] and A[1] = 3 + 7 = 10, which is closest to the value K(= 10).

Input: A[] = {2, 3}, B[] = {4, 5, 30}, K = 18
Output: 17

Approach: The given problem can be solved by using recursion, by finding the sum of elements of the subsets of the array B[] having sum closest to (K – A[i]) for each array element A[i]. Follow the steps below to solve the problem:

• Initialize two variables, say mini as INT_MAX and ans as INT_MAX to store the minimum absolute difference and the value closest to K.
• Define a recursive function, say findClosest(arr, i, currSum) to find the subset-sum of the array closest to K, where i is the index in the array B[] and currSum stores the sum of the subset.
• If the value of i is at least M, then return from the function.
• If the absolute value of (currSum – K) is less than mini, then update the value of mini as abs(currSum – K) and update the value of ans as currSum.
• If the absolute value of (currSum – K) is equal to mini then, update the value of ans as the minimum of ans and currSum.
• Call the recursive function excluding the element B[i] as findClosest(i + 1, currSum).
• Call the recursive function including the element B[i] once as findClosest(i + 1, currSum + B[i]).
• Call the recursive function including the element B[i] twice as findClosest(i + 1, currSum + 2*B[i]).
• Traverse the given array A[] and for every element call the function findClosest(0, A[i]).
• After completing the above steps, print the value of ans as the resultant sum.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach`   `#include ` `using` `namespace` `std;`   `// Stores the sum closest to K` `int` `ans = INT_MAX;`   `// Stores the minimum absolute difference` `int` `mini = INT_MAX;`   `// Function to choose the elements` `// from the array B[]` `void` `findClosestTarget(``int` `i, ``int` `curr,` `                       ``int` `B[], ``int` `M,` `                       ``int` `K)` `{`   `    ``// If absolute difference is less` `    ``// then minimum value` `    ``if` `(``abs``(curr - K) < mini) {`   `        ``// Update the minimum value` `        ``mini = ``abs``(curr - K);`   `        ``// Update the value of ans` `        ``ans = curr;` `    ``}`   `    ``// If absolute difference between` `    ``// curr and K is equal to minimum` `    ``if` `(``abs``(curr - K) == mini) {`   `        ``// Update the value of ans` `        ``ans = min(ans, curr);` `    ``}`   `    ``// If i is greater than M - 1` `    ``if` `(i >= M)` `        ``return``;`   `    ``// Includes the element B[i] once` `    ``findClosestTarget(i + 1, curr + B[i],` `                      ``B, M, K);`   `    ``// Includes the element B[i] twice` `    ``findClosestTarget(i + 1, curr + 2 * B[i],` `                      ``B, M, K);`   `    ``// Excludes the element B[i]` `    ``findClosestTarget(i + 1, curr, B, M, K);` `}`   `// Function to find a subset sum` `// whose sum is closest to K` `int` `findClosest(``int` `A[], ``int` `B[],` `                ``int` `N, ``int` `M, ``int` `K)` `{` `    ``// Traverse the array A[]` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Function Call` `        ``findClosestTarget(0, A[i], B,` `                          ``M, K);` `    ``}`   `    ``// Return the ans` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Input` `    ``int` `A[] = { 2, 3 };` `    ``int` `B[] = { 4, 5, 30 };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``int` `M = ``sizeof``(B) / ``sizeof``(B[0]);` `    ``int` `K = 18;`   `    ``// Function Call` `    ``cout << findClosest(A, B, N, M, K);`   `    ``return` `0;` `}`

## Java

 `// java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `public` `class` `GFG {`   `    ``// Stores the sum closest to K` `    ``static` `int` `ans = Integer.MAX_VALUE;`   `    ``// Stores the minimum absolute difference` `    ``static` `int` `mini = Integer.MAX_VALUE;`   `    ``// Function to choose the elements` `    ``// from the array B[]` `    ``static` `void` `findClosestTarget(``int` `i, ``int` `curr, ``int` `B[],` `                                  ``int` `M, ``int` `K)` `    ``{`   `        ``// If absolute difference is less` `        ``// then minimum value` `        ``if` `(Math.abs(curr - K) < mini) {`   `            ``// Update the minimum value` `            ``mini = Math.abs(curr - K);`   `            ``// Update the value of ans` `            ``ans = curr;` `        ``}`   `        ``// If absolute difference between` `        ``// curr and K is equal to minimum` `        ``if` `(Math.abs(curr - K) == mini) {`   `            ``// Update the value of ans` `            ``ans = Math.min(ans, curr);` `        ``}`   `        ``// If i is greater than M - 1` `        ``if` `(i >= M)` `            ``return``;`   `        ``// Includes the element B[i] once` `        ``findClosestTarget(i + ``1``, curr + B[i], B, M, K);`   `        ``// Includes the element B[i] twice` `        ``findClosestTarget(i + ``1``, curr + ``2` `* B[i], B, M, K);`   `        ``// Excludes the element B[i]` `        ``findClosestTarget(i + ``1``, curr, B, M, K);` `    ``}`   `    ``// Function to find a subset sum` `    ``// whose sum is closest to K` `    ``static` `int` `findClosest(``int` `A[], ``int` `B[], ``int` `N, ``int` `M,` `                           ``int` `K)` `    ``{` `        ``// Traverse the array A[]` `        ``for` `(``int` `i = ``0``; i < N; i++) {`   `            ``// Function Call` `            ``findClosestTarget(``0``, A[i], B, M, K);` `        ``}`   `        ``// Return the ans` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Input` `        ``int` `A[] = { ``2``, ``3` `};` `        ``int` `B[] = { ``4``, ``5``, ``30` `};` `        ``int` `N = A.length;` `        ``int` `M = B.length;` `        ``int` `K = ``18``;`   `        ``// Function Call` `        ``System.out.print(findClosest(A, B, N, M, K));` `    ``}` `}`   `// This code is contributed by Kingash.`

## Python3

 `# Python3 program of the above approach`   `# Stores the sum closest to K` `ans ``=` `10``*``*``8`   `# Stores the minimum absolute difference` `mini ``=` `10``*``*``8`   `# Function to choose the elements` `# from the array B[]` `def` `findClosestTarget(i, curr, B, M, K):` `    ``global` `ans, mini` `    `  `    ``# If absolute difference is less` `    ``# then minimum value` `    ``if` `(``abs``(curr ``-` `K) < mini):`   `        ``# Update the minimum value` `        ``mini ``=` `abs``(curr ``-` `K)`   `        ``# Update the value of ans` `        ``ans ``=` `curr`   `    ``# If absolute difference between` `    ``# curr and K is equal to minimum` `    ``if` `(``abs``(curr ``-` `K) ``=``=` `mini):` `      `  `        ``# Update the value of ans` `        ``ans ``=` `min``(ans, curr)`   `    ``# If i is greater than M - 1` `    ``if` `(i >``=` `M):` `        ``return`   `    ``# Includes the element B[i] once` `    ``findClosestTarget(i ``+` `1``, curr ``+` `B[i], B, M, K)`   `    ``# Includes the element B[i] twice` `    ``findClosestTarget(i ``+` `1``, curr ``+` `2` `*` `B[i], B, M, K)`   `    ``# Excludes the element B[i]` `    ``findClosestTarget(i ``+` `1``, curr, B, M, K)`   `# Function to find a subset sum` `# whose sum is closest to K` `def` `findClosest(A, B, N, M, K):` `  `  `    ``# Traverse the array A[]` `    ``for` `i ``in` `range``(N):` `      `  `        ``# Function Call` `        ``findClosestTarget(``0``, A[i], B, M, K)`   `    ``# Return the ans` `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``# Input` `    ``A ``=` `[``2``, ``3``]` `    ``B ``=` `[``4``, ``5``, ``30``]` `    ``N ``=` `len``(A)` `    ``M ``=` `len``(B)` `    ``K ``=` `18`   `    ``# Function Call` `    ``print` `(findClosest(A, B, N, M, K))`   `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program of the above approach` `using` `System;` `class` `GFG ` `{` `  `  `    ``// Stores the sum closest to K` `    ``static` `int` `ans = Int32.MaxValue;`   `    ``// Stores the minimum absolute difference` `    ``static` `int` `mini = Int32.MaxValue;`   `    ``// Function to choose the elements` `    ``// from the array B[]` `    ``static` `void` `findClosestTarget(``int` `i, ``int` `curr, ``int``[] B,` `                                  ``int` `M, ``int` `K)` `    ``{`   `        ``// If absolute difference is less` `        ``// then minimum value` `        ``if` `(Math.Abs(curr - K) < mini) {`   `            ``// Update the minimum value` `            ``mini = Math.Abs(curr - K);`   `            ``// Update the value of ans` `            ``ans = curr;` `        ``}`   `        ``// If absolute difference between` `        ``// curr and K is equal to minimum` `        ``if` `(Math.Abs(curr - K) == mini) {`   `            ``// Update the value of ans` `            ``ans = Math.Min(ans, curr);` `        ``}`   `        ``// If i is greater than M - 1` `        ``if` `(i >= M)` `            ``return``;`   `        ``// Includes the element B[i] once` `        ``findClosestTarget(i + 1, curr + B[i], B, M, K);`   `        ``// Includes the element B[i] twice` `        ``findClosestTarget(i + 1, curr + 2 * B[i], B, M, K);`   `        ``// Excludes the element B[i]` `        ``findClosestTarget(i + 1, curr, B, M, K);` `    ``}`   `    ``// Function to find a subset sum` `    ``// whose sum is closest to K` `    ``static` `int` `findClosest(``int``[] A, ``int``[] B, ``int` `N, ``int` `M,` `                           ``int` `K)` `    ``{` `      `  `        ``// Traverse the array A[]` `        ``for` `(``int` `i = 0; i < N; i++) {`   `            ``// Function Call` `            ``findClosestTarget(0, A[i], B, M, K);` `        ``}`   `        ``// Return the ans` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``// Input` `        ``int``[] A = { 2, 3 };` `        ``int``[] B = { 4, 5, 30 };` `        ``int` `N = A.Length;` `        ``int` `M = B.Length;` `        ``int` `K = 18;`   `        ``// Function Call` `        ``Console.WriteLine(findClosest(A, B, N, M, K));` `    ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

`17`

Time Complexity: O(N * 3M)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up