2 Sum – Pair Sum Closest to Target using Binary Search
Last Updated :
07 Jan, 2025
Improve
Given an array arr[] of n integers and an integer target, the task is to find a pair in arr[] such that it’s sum is closest to target.
Note: Return the pair in sorted order and if there are multiple such pairs return the pair with maximum absolute difference. If no such pair exists return an empty array.
Examples:
Input: arr[] = [10, 30, 20, 5], target = 25
Output: [5, 20]
Explanation: Out of all the pairs, [5, 20] has sum = 25 which is closest to 25.
Input: arr[] = [5, 2, 7, 1, 4], target = 10
Output: [2, 7]
Explanation: As (4, 7) and (2, 7) both are closest to 10, but absolute difference of (2, 7) is 5 and (4, 7) is 3. Hence,[2, 7] has maximum absolute difference and closest to target.Input: arr[] = [10], target = 10
Output: []
Explanation: As the input array has only 1 element, return an empty array.
We have already discussed the Naive and Expected Approach in 2 Sum – Pair Sum Closest to Target. In this post, we will be discussing the Binary Search based approach.
Using Binary Search – O(2*n log(n)) Time and O(1) Space
As the given input array is sorted, so we can use this property to find the second element in a pair more efficiently using binary search. First, iterate over the array and for each element arr[i], binary search on the remaining array for the element closest to its complement, that is (target – arr[i]). While searching, we can have three cases:
- arr[mid] == complement: we have found an element which can pair with arr[i] to give pair sum = target.
- arr[mid] < complement: we need to search for a greater element, so update lo = mid + 1.
- arr[mid] > complement: we need to search for a lesser element, so update hi = mid – 1.
Note: In this approach, we don’t need to separately handle the case when there is a tie between pairs and we need to select the one with maximum absolute difference. This is because we are selecting the first element of the pair in increasing order, so if we have a tie between two pairs, we can always choose the first pair.
// C++ Code to find pair with closest sum using Binary Search
#include <bits/stdc++.h>
using namespace std;
// Find element closest to complement using binary search
int findClosest(vector<int>& arr, int lo, int hi, int complement) {
int res = arr[lo];
while (lo <= hi) {
int mid = (lo + hi) / 2;
// Update answer if we find a closer element
if (abs(arr[mid] - complement) < abs(res - complement))
res = arr[mid];
// If there is a tie, then we pick the larger value
else if(abs(arr[mid] - complement) == abs(res - complement))
res = max(res, arr[mid]);
if (arr[mid] == complement)
return arr[mid];
else if (arr[mid] < complement)
lo = mid + 1;
else
hi = mid - 1;
}
return res;
}
// Find pair with sum closest to target and max absolute difference
vector<int> sumClosest(vector<int>& arr, int target) {
int n = arr.size();
sort(arr.begin(), arr.end());
vector<int> res;
int minDiff = INT_MAX;
for (int i = 0; i < n - 1; i++) {
// Use binary search in arr[i+1...n-1] to
// find the element closest to (target - arr[i])
int complement = target - arr[i];
int closest = findClosest(arr, i + 1, n - 1, complement);
int currDiff = abs(target - arr[i] - closest);
if(currDiff < minDiff) {
minDiff = currDiff;
res = {arr[i], closest};
}
}
return res;
}
int main() {
vector<int> arr = {5, 2, 7, 1, 4};
int target = 10;
vector<int> res = sumClosest(arr, target);
if(res.size() > 0)
cout << res[0] << " " << res[1];
return 0;
}
// C Code to find pair with closest sum using Binary Search
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
// Find element closest to complement using binary search
int findClosest(int* arr, int lo, int hi, int complement) {
int res = arr[lo];
while (lo <= hi) {
int mid = (lo + hi) / 2;
// Update answer if we find a closer element
if (abs(arr[mid] - complement) < abs(res - complement))
res = arr[mid];
// If there is a tie, then we pick the larger value
else if(abs(arr[mid] - complement) == abs(res - complement))
res = (res > arr[mid]) ? res : arr[mid];
if (arr[mid] == complement)
return arr[mid];
else if (arr[mid] < complement)
lo = mid + 1;
else
hi = mid - 1;
}
return res;
}
// Function to compare elements for sorting
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// Find pair with sum closest to target and max absolute difference
int* sumClosest(int* arr, int n, int target) {
qsort(arr, n, sizeof(int), compare);
// If the array has fewer than 2 elements, return an empty array
if (n < 2) {
return NULL;
}
int* res = (int*)malloc(2 * sizeof(int));
int minDiff = INT_MAX;
for (int i = 0; i < n - 1; i++) {
// Use binary search in arr[i+1...n-1] to
// find the element closest to (target - arr[i])
int complement = target - arr[i];
int closest = findClosest(arr, i + 1, n - 1, complement);
int currDiff = abs(target - arr[i] - closest);
if(currDiff < minDiff) {
minDiff = currDiff;
res[0] = arr[i];
res[1] = closest;
}
}
return res;
}
int main() {
int arr[] = {5, 2, 7, 1, 4};
int target = 10;
int n = sizeof(arr) / sizeof(arr[0]);
int* res = sumClosest(arr, n, target);
// Check if the result array is not NULL
if (res != NULL)
printf("%d %d\n", res[0], res[1]);
return 0;
}
// Java Code to find pair with closest sum using Binary Search
import java.util.*;
class GfG {
// Find element closest to complement using binary search
static int findClosest(int[] arr, int lo, int hi, int complement) {
int res = arr[lo];
while (lo <= hi) {
int mid = (lo + hi) / 2;
// Update answer if we find a closer element
if (Math.abs(arr[mid] - complement) < Math.abs(res - complement))
res = arr[mid];
// If there is a tie, then we pick the larger value
else if (Math.abs(arr[mid] - complement) == Math.abs(res - complement))
res = Math.max(res, arr[mid]);
if (arr[mid] == complement)
return arr[mid];
else if (arr[mid] < complement)
lo = mid + 1;
else
hi = mid - 1;
}
return res;
}
// Find pair with sum closest to target and max absolute difference
static List<Integer> sumClosest(int[] arr, int target) {
int n = arr.length;
Arrays.sort(arr);
List<Integer> res = new ArrayList<>();
int minDiff = Integer.MAX_VALUE;
for (int i = 0; i < n - 1; i++) {
// Use binary search in arr[i+1...n-1] to
// find the element closest to (target - arr[i])
int complement = target - arr[i];
int closest = findClosest(arr, i + 1, n - 1, complement);
int currDiff = Math.abs(target - arr[i] - closest);
if (currDiff < minDiff) {
minDiff = currDiff;
res = Arrays.asList(arr[i], closest);
}
}
return res;
}
public static void main(String[] args) {
int[] arr = {5, 2, 7, 1, 4};
int target = 10;
List<Integer> res = sumClosest(arr, target);
if (res.size() > 0) {
System.out.println(res.get(0) + " " + res.get(1));
}
}
}
# Python Code to find pair with closest sum using Binary Search
# Find element closest to complement using binary search
def findClosest(arr, lo, hi, complement):
res = arr[lo]
while lo <= hi:
mid = (lo + hi) // 2
# Update answer if we find a closer element
if abs(arr[mid] - complement) < abs(res - complement):
res = arr[mid]
# If there is a tie, then we pick the larger value
elif abs(arr[mid] - complement) == abs(res - complement):
res = max(res, arr[mid])
if arr[mid] == complement:
return arr[mid]
elif arr[mid] < complement:
lo = mid + 1
else:
hi = mid - 1
return res
# Find pair with sum closest to target and max absolute difference
def sumClosest(arr, target):
n = len(arr)
arr.sort()
res = []
minDiff = float('inf')
for i in range(n - 1):
# Use binary search in arr[i+1...n-1] to
# find the element closest to (target - arr[i])
complement = target - arr[i]
closest = findClosest(arr, i + 1, n - 1, complement)
currDiff = abs(target - arr[i] - closest)
if currDiff < minDiff:
minDiff = currDiff
res = [arr[i], closest]
return res
if __name__ == "__main__":
arr = [5, 2, 7, 1, 4]
target = 10
res = sumClosest(arr, target)
if len(res) > 0:
print(res[0], res[1])
// C# Code to find pair with closest sum using Binary Search
using System;
using System.Collections.Generic;
class GfG {
// Find element closest to complement using binary search
static int findClosest(int[] arr, int lo, int hi, int complement) {
int res = arr[lo];
while (lo <= hi) {
int mid = (lo + hi) / 2;
// Update answer if we find a closer element
if (Math.Abs(arr[mid] - complement) < Math.Abs(res - complement))
res = arr[mid];
// If there is a tie, then we pick the larger value
else if (Math.Abs(arr[mid] - complement) == Math.Abs(res - complement))
res = Math.Max(res, arr[mid]);
if (arr[mid] == complement)
return arr[mid];
else if (arr[mid] < complement)
lo = mid + 1;
else
hi = mid - 1;
}
return res;
}
// Find pair with sum closest to target and max absolute difference
static List<int> sumClosest(int[] arr, int target) {
int n = arr.Length;
Array.Sort(arr);
List<int> res = new List<int>();
int minDiff = int.MaxValue;
for (int i = 0; i < n - 1; i++) {
// Use binary search in arr[i+1...n-1] to
// find the element closest to (target - arr[i])
int complement = target - arr[i];
int closest = findClosest(arr, i + 1, n - 1, complement);
int currDiff = Math.Abs(target - arr[i] - closest);
if (currDiff < minDiff) {
minDiff = currDiff;
res = new List<int> { arr[i], closest };
}
}
return res;
}
static void Main() {
int[] arr = { 5, 2, 7, 1, 4 };
int target = 10;
List<int> res = sumClosest(arr, target);
if (res.Count > 0)
Console.WriteLine(res[0] + " " + res[1]);
}
}
// JavaScript Code to find pair with closest sum using Binary Search
// Find element closest to complement using binary search
function findClosest(arr, lo, hi, complement) {
let res = arr[lo];
while (lo <= hi) {
let mid = Math.floor((lo + hi) / 2);
// Update answer if we find a closer element
if (Math.abs(arr[mid] - complement) <
Math.abs(res - complement)) {
res = arr[mid];
}
// If there is a tie, then we pick the larger value
else if (Math.abs(arr[mid] - complement) ===
Math.abs(res - complement)) {
res = Math.max(res, arr[mid]);
}
if (arr[mid] === complement) {
return arr[mid];
} else if (arr[mid] < complement) {
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return res;
}
// Find pair with sum closest to target and max absolute difference
function sumClosest(arr, target) {
let n = arr.length;
arr.sort((a, b) => a - b);
let res = [];
let minDiff = Number.MAX_SAFE_INTEGER;
for (let i = 0; i < n - 1; i++) {
// Use binary search in arr[i+1...n-1] to
// find the element closest to (target - arr[i])
let complement = target - arr[i];
let closest = findClosest(arr, i + 1, n - 1, complement);
let currDiff = Math.abs(target - arr[i] - closest);
if (currDiff < minDiff) {
minDiff = currDiff;
res = [arr[i], closest];
}
}
return res;
}
// Driver Code
let arr = [5, 2, 7, 1, 4];
let target = 10;
let res = sumClosest(arr, target);
if (res.length > 0)
console.log(res[0], res[1]);
Output
2 7
