4Sum Java

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note:

• Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)
• The solution set must not contain duplicate quadruplets.

    For example, given array S = {1 0 -1 0 -2 2}, and target = 0.

    A solution set is:
    (-1,  0, 0, 1)
    (-2, -1, 1, 2)
    (-2,  0, 0, 2)

Have you been asked this question in an interview? 

Check for coding in detail:

/*Solution: Time O(n^3)
    key to solve: The Nested loop, two Index(start & end), HashSet avoid duplication
    Do not forget to sort Input Array first
    This is typical way to solve "K-Sum" problem
    Time complexity of K-Sum is O(n^(k-1))
     */
    public static List<List<Integer>> fourSum(int[] num, int target) {
        List<List<Integer>> quadruplet = new ArrayList<List<Integer>>();
        List<Integer> sub = new ArrayList<Integer>();
        //To aviod Duplication
        HashSet<List<Integer>> set = new HashSet<List<Integer>>();
        int len = num.length;
        Arrays.sort(num);
        for (int i = 0; i < len - 3; i++) {
            for (int j = i + 1; j < len - 2; j++) {
                int start = j + 1;
                int end = len - 1;
                while (start < end) {
                    if (num[i]+num[j] + num[start] + num[end] == target) {
                        sub.add(num[i]);
                        sub.add(num[j]);
                        sub.add(num[start]);
                        sub.add(num[end]);
                        if (!set.contains(sub)) {
                            set.add(sub);
                            quadruplet.add(new ArrayList<Integer>(sub));
                        }
                        sub.clear();
                        start++;
                        end--;
                    } else if (target > num[i]+ num[j] + num[start] + num[end]) {
                        start++;
                    } else {
                        end--;
                    }
                }
            }
        }
        return quadruplet;
    }