Find all distinct quadruplets in an array that sum up to a given value - GeeksforGeeks

12 May, 2021
Given an array arr[] consisting of N integers and an integer K, the task is to print all possible unique quadruplets (arr[i], arr[j], arr[k], arr[l]) whose sum is K such that all their indices are distinct.
Examples:
Input: arr[] = {1, 0, -1, 0, -2, 2}, K = 0Output:-2 -1 1 2-2 0 0 2-1 0 0 1Explanation:Below are the quadruplets whose sum is K (= 0):
{-2, -1, 1, 2}
{-2, 0, 0, 2}
{-1, 0, 0, 1}
Input: arr[] = {1, 2, 3, -1}, target = 5Output:1 2 3 -1
Naive Approach: The simplest approach is to generate all possible quadruplets from the given array arr[] and if the sum of elements of the quadruplets is K, then insert the current quadruplets in the HashSet to avoid the count of duplicates quadruplets. After checking for all the quadruplets, print all the quadruplets stored in the HashSet.
Time Complexity: O(N4)Auxiliary Space: O(N4)
Efficient Approach: The above approach can also be optimized by using the idea of generating all possible pairs of the given array. Follow the given steps to solve the problem:
Initialize a HashMap, say ans that stores all the possible quadruplets.
Initialize a HashMap, say M that stores the sum of all possible pairs of the given array with their corresponding indices.
Generate all possible pairs of the given array and store the sum of all pairs of elements (arr[i], arr[j]) with their indices (i, j) in the HashMap M.
Now, generate all possible pairs of the given array again and for each sum of all pairs of elements (arr[i], arr[j]) if the value (K – sum) exists in the HashMap M, then store the current quadruplets in the HashMap ans.
After completing the above steps, print all the quadruplets stored in the HashMap ans.
Below is the implementation of the above approach:
Java
// Java program for the above approach  import java.io.*;import java.util.*;  public class GFG {      // Stores the pair of indices    static class Pair {          int index1;        int index2;          // Constructor        Pair(int x, int y)        {            index1 = x;            index2 = y;        }    }      // Function to find the all the    // unique quadruplets with the    // elements at different indices    public static void    GetQuadruplets(ArrayList<Integer> nums,                   int target)    {          // Stores the sum mapped to        // a List Of Pair<i, j>        HashMap<Integer, ArrayList<Pair> > map            = new HashMap<>();          // Generate all possible pairs        // for the HashMap        for (int i = 0;             i < nums.size() - 1; i++) {              for (int j = i + 1;                 j < nums.size(); j++) {                  // Find the sum of pairs                // of elements                int sum = nums.get(i)                          + nums.get(j);                  // If the sum doesn't                // exists then update                // with the new pairs                if (!map.containsKey(sum)) {                      ArrayList<Pair> temp                        = new ArrayList<>();                    Pair p = new Pair(i, j);                    temp.add(p);                      // Update the hashmap                    map.put(sum, temp);                }                  // Otherwise, push the new                // pair of indices to the                // current sum                else {                      ArrayList<Pair> temp                        = map.get(sum);                      Pair p = new Pair(i, j);                    temp.add(p);                      // Update the hashmap                    map.put(sum, temp);                }            }        }          // Stores all the Quadruplets        HashSet<ArrayList<Integer> > ans            = new HashSet<ArrayList<Integer> >();          for (int i = 0;             i < nums.size() - 1; i++) {              for (int j = i + 1;                 j < nums.size(); j++) {                  int lookUp = target                             - (nums.get(i)                                + nums.get(j));                  // If the sum with value                // (K - sum) exists                if (map.containsKey(lookUp)) {                      // Get the pair of                    // indices of sum                    ArrayList<Pair> temp                        = map.get(lookUp);                      for (Pair pair : temp) {                          // Check if i, j, k                        // and l are distinct                        // or not                        if (pair.index1 != i                            && pair.index1 != j                            && pair.index2 != i                            && pair.index2 != j) {                              ArrayList<Integer> values                                = new ArrayList<>();                            values.add(                                nums.get(pair.index1));                            values.add(                                nums.get(pair.index2));                            values.add(nums.get(i));                            values.add(nums.get(j));                              // Sort the list to                            // avoid duplicacy                            Collections.sort(values);                              // Update the hashset                            ans.add(values);                        }                    }                }            }        }          // Print all the Quadruplets        for (ArrayList<Integer> arr : ans) {            System.out.println(arr);        }    }      // Driver Code    public static void main(String[] args)    {        ArrayList<Integer> arr = new ArrayList<>();        arr.add(1);        arr.add(0);        arr.add(-1);        arr.add(0);        arr.add(-2);        arr.add(2);        int K = 0;        GetQuadruplets(arr, K);    }}
[-2, 0, 0, 2]
[-1, 0, 0, 1]
[-2, -1, 1, 2]

Time Complexity: O(N2 * log N)Auxiliary Space: O(N2)
HashSet
HashTable
Java-ArrayList
Java-HashMap
Picked
Arrays
Hash
Mathematical
Arrays
Hash
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Window Sliding Technique
Trapping Rain Water
Building Heap from Array
Reversal algorithm for array rotation
Program to find sum of elements in a given array
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)
Count pairs with given sum
Hashing | Set 2 (Separate Chaining)