# 4 Sum | Find Quads that add up to a target value

Problem Statement: Given an array of N integers, your task is to find unique quads that add up to give a target value. In short, you need to return an array of all the unique quadruplets [arr[a], arr[b], arr[c], arr[d]] such that their sum is equal to a given target.

Pre-req: Binary Search and 2-sum problem

Note:

• 0 <= a, b, c, d < n
• a, b, c, and d are distinct.
• arr[a] + arr[b] + arr[c] + arr[d] == target

Example 1:

```Input Format: arr[] = [1,0,-1,0,-2,2], target = 0

Result: [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

Explanation: We have to find unique quadruplets from
the array such that the sum of those elements is
equal to the target sum given that is 0.

The result obtained is such that the sum of the

Example 2:

```Input Format: arr[] = [4,3,3,4,4,2,1,2,1,1], target = 9

Result: [[1,1,3,4],[1,2,2,4],[1,2,3,3]]```

Solution:

Disclaimer: Don’t jump directly to the solution, try it out yourself first.

Solution 1: Using 3 pointers and Binary Search

Intuition: Approach:

The main idea is to sort the array, and then we can think of searching in the array using the binary search technique. Since we need the 4 numbers which sum up to target. So we will fix three numbers as nums[i], nums[j] and nums[k], and search for the remaining (target – (nums[i] + nums[j] + nums[k])) in the array. Since we sorted the array during the start, we can apply binary search to search for this value, and if it occurs we can store them. In order to get the unique quads, we use a set data structure to store them.

Code:

## C++ Code

``````#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
int n = nums.size();

sort(nums.begin(),nums.end());

set<vector<int>> sv;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{

for(int k=j+1;k<n;k++)
{

int x = (long long)target -
(long long)nums[i]-
(long long)nums[j]-(long long)nums[k];

if(binary_search(nums.begin()+k+1,nums.end(),x)){
vector<int> v;
v.push_back(nums[i]);
v.push_back(nums[j]);
v.push_back(nums[k]);
v.push_back(x);
sort(v.begin(),v.end());
sv.insert(v);
}
}
}
}
vector<vector<int>> res(sv.begin(),sv.end());
return res;
}
};
int main()
{
Solution obj;
vector<int> v{1,0,-1,0,-2,2};

vector<vector<int>> sum=obj.fourSum(v,0);
cout<<"The unique quadruplets are"<<endl;
for (int i = 0; i < sum.size(); i++) {
for (int j = 0; j < sum[i].size(); j++)
cout << sum[i][j] << " ";
cout << endl;
}
}``````

Output:

The unique quadruplets are
-2 -1 1 2
-2 0 0 2
-1 0 0 1

Time Complexity: O(N log N + N³ logN)
Reason: Sorting the array takes N log N and three nested loops will be taking and for binary search, it takes another log N.
Space Complexity: O(1), (Generally the space complexity that is used to return the answer is ignored)

Solution 2: Optimized Approach

Intuition: In the previous approach we fixed three-pointers and did a binary search to find the fourth. Over here we will fix two-pointers and then find the remaining two elements using two pointer technique as the array will be sorted at first.

Approach: Sort the array, and then fix two pointers, so the remaining sum will be (target – (nums[i] + nums[j])). Now we can fix two-pointers, one front, and another back, and easily use a two-pointer to find the remaining two numbers of the quad. In order to avoid duplications, we jump the duplicates, because taking duplicates will result in repeating quads. We can easily jump duplicates, by skipping the same elements by running a loop.

Dry-run: In case you want to see the dry run of this approach, please watch the video at the bottom.

Code:

## C++ Code

``````#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& num, int target) {
vector<vector<int> > res;

if (num.empty())
return res;
int n = num.size();
sort(num.begin(),num.end());

for (int i = 0; i < n; i++) {

int target_3 = target - num[i];

for (int j = i + 1; j < n; j++) {

int target_2 = target_3 - num[j];

int front = j + 1;
int back = n - 1;

while(front < back) {

int two_sum = num[front] + num[back];

if (two_sum < target_2) front++;

else if (two_sum > target_2) back--;

else {

// Processing the duplicates of number 3
while (front < back && num[front] == quadruplet) ++front;

// Processing the duplicates of number 4
while (front < back && num[back] == quadruplet) --back;

}
}

// Processing the duplicates of number 2
while(j + 1 < n && num[j + 1] == num[j]) ++j;
}

// Processing the duplicates of number 1
while (i + 1 < n && num[i + 1] == num[i]) ++i;

}

return res;
}
};

int main()
{
Solution obj;
vector<int> v{1,0,-1,0,-2,2};

vector<vector<int>> sum=obj.fourSum(v,0);
cout<<"The unique quadruplets are"<<endl;
for (int i = 0; i < sum.size(); i++) {
for (int j = 0; j < sum[i].size(); j++)
cout << sum[i][j] << " ";
cout << endl;
}
}``````

Time Complexity: O(n³)
Reason: There are 2 nested loops and the front pointer as well as the right pointer (Third nested loop)

Space Complexity: O(1), (Generally the space complexity that is used to return the answer is ignored)

## Java Code

``````import java.io.*;
import java.util.*;
class Solution {
public List<List<Integer>> fourSum(int[] num, int target) {
ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();

if (num == null || num.length == 0)
return res;

int n = num.length;

Arrays.sort(num);

for (int i = 0; i < n; i++) {

int target_3 = target - num[i];

for (int j = i + 1; j < n; j++) {

int target_2 = target_3 - num[j];

int front = j + 1;
int back = n - 1;

while(front < back) {

int two_sum = num[front] + num[back];

if (two_sum < target_2) front++;

else if (two_sum > target_2) back--;

else {

List<Integer> quad = new ArrayList<>();

// Processing the duplicates of number 3
while (front < back && num[front] == quad.get(2)) ++front;

// Processing the duplicates of number 4
while (front < back && num[back] == quad.get(3)) --back;

}
}

// Processing the duplicates of number 2
while(j + 1 < n && num[j + 1] == num[j]) ++j;
}

// Processing the duplicates of number 1
while (i + 1 < n && num[i + 1] == num[i]) ++i;

}

return res;
}
};
class TUF {
public static void main (String[] args) {
int arr[] = {1,0,-1,0,-2,2};
int target = 0;
Solution sol = new Solution();
List<List<Integer>> ls = sol.fourSum(arr, target);
//System.out.println("raj");
for(int i = 0;i<ls.size();i++) {
for(int j = 0;j<ls.get(i).size();j++) {
System.out.print(ls.get(i).get(j) + " ");
}
System.out.println();
}
}
}``````

Output:

The unique quadruplets are
-2 -1 1 2
-2 0 0 2
-1 0 0 1

Time Complexity: O(n³)
Reason: There are 2 nested loops and the front pointer as well as the right pointer (Third nested loop)

Space Complexity: O(1), (Generally the space complexity that is used to return the answer is ignored)

Special thanks to Rishiraj Girmal for contributing to this article on takeUforward. If you also wish to share your knowledge with the takeUforward fam, please check out this article