4 sum

Given an array S _of _n _integers, are there elements_a,b,c, andd_in_S_such that_a + b + c + d = target?

Find all unique quadruplets in the array which gives the sum of target.

Notice

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.

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)

Solution: Two pointer. The same as 3sum. The point to learn is how to cut leaves(skip duplicate without hashset).

public ArrayList<ArrayList<Integer>> fourSum(int[] numbers, int target) {
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
    if(numbers == null || numbers.length == 0) {
        return res;
    }
    Arrays.sort(numbers);
    for(int i = 0; i < numbers.length; i++) {
        if(i > 0 && numbers[i] == numbers[i - 1]) {
            continue;
        }
        for(int j = i + 1; j < numbers.length; j++) {
            if(j > i + 1 && numbers[j] == numbers[j - 1]) {
                continue;
            }
            int left = j + 1, right = numbers.length - 1;
            while(left < right) {
                int sum = numbers[i] + numbers[j] + numbers[left] + numbers[right];
                if(sum == target) {
                    ArrayList<Integer> ans = new ArrayList<Integer>();
                    ans.add(numbers[i]);
                    ans.add(numbers[j]);
                    ans.add(numbers[left]);
                    ans.add(numbers[right]);
                    res.add(ans);
                    left++;
                    right--;
                    while(left <= right && numbers[left] == numbers[left - 1]) {
                        left++;
                    }
                    while(left <= right && numbers[right] == numbers[right + 1]) {
                        right--;
                    }
                }
                else if(sum < target) {
                    left++;
                }
                else {
                    right--;
                }
            }
        }
    }
    return res;
}