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的基础上稍微修改即可，O(n ^ 3)。

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
         Arrays.sort(num);
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(num == null || num.length < 4) return result;
        int len = num.length;
        for(int i = 0; i <= num.length - 4; i ++){
            if(i==0 || num[i] > num[i-1]){
                for(int a = num.length - 1; a > i + 2; a --){
                    if(a == num.length - 1 || num[a] < num[a + 1]){
                        int j = i + 1;
                        int h = a - 1;
                        while(j < h){
                            int sum = num[j] + num[h] + num[i] + num[a];
                            if(sum == target){
                                ArrayList<Integer> row = new ArrayList<Integer>();
                                row.add(num[i]);
                                row.add(num[j]);
                                row.add(num[h]);
                                row.add(num[a]);
                                result.add(row);
                                h--;
                                j++;
                                while(h>j && num[h]==num[h+1]) h--; 
        
                                while(j<h && num[j]==num[j-1]) j++;
                            }else if(sum < target){
                                    j ++;
                            }else if(sum > target){
                                    h --;
                            }
                        }
                    }
                }
            }
        }
        return result;
    }
}