Leetcode: 4Sum

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)

思路：和3sum思想一致，排序后，遍历最小值，并往右相加。

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (num == null || num.length < 4) {
            return res;
        }
        
        Arrays.sort(num);
        for (int first = 0; first < num.length - 3; first++) {
            if (first != 0 && num[first] == num[first - 1]) {
                continue;
            }
            for (int second = first + 1; second < num.length - 2; second++) {
                if (second != first + 1 && num[second] == num[second - 1]) {
                    continue;
                }
                int third = second + 1;
                int fourth = num.length - 1;
                while (third < fourth) {
                    int sum = num[first] + num[second] + num[third] + num[fourth];
                    if (sum == target) {
                        ArrayList<Integer> item = new ArrayList<Integer>();
                        item.add(num[first]);
                        item.add(num[second]);
                        item.add(num[third]);
                        item.add(num[fourth]);
                        res.add(item);
                        third++;
                        fourth--;
                        while (third < fourth && num[third] == num[third - 1]) {
                            third++;
                        }
                        while (third < fourth && num[fourth] == num[fourth + 1]) {
                            fourth--;
                        }
                    } else if (sum > target) {
                        fourth--;
                    } else {
                        third++;
                    }
                }
            }
        }
        
        return res;
    }
}