18. 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: 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]
]

Subscribe to see which companies asked this question

第一次 84ms：

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        
        
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(nums.length == 0)
            return result;
        Arrays.sort(nums);
        List<Integer> nowNode = null;
        
        int fixed1=0, fixed2;
        int first, last;
        int l = nums.length;
        int sum = 0;
        boolean isExist = false;
        
        while(fixed1 <= (l - 4)){
            fixed2 = fixed1 + 1;
            while(fixed2 <= (l - 3)){
                first = fixed2 + 1;
                last = l - 1;
                while(first < last){
                    isExist = false;
                    sum = nums[fixed1] + nums[fixed2] + nums[first] + nums[last];
                    if(sum < target){
                        first++;
                    }else if(sum > target){
                        last--;
                    }else{
                        
                        for(List<Integer> templ : result){
                            if(nums[fixed1] == templ.get(0) && nums[fixed2] == templ.get(1) && nums[first] == templ.get(2) 
                            && nums[last] == templ.get(3)){
                                isExist = true;
                                break;
                            }
                        }
                        if(!isExist){
                            nowNode = new ArrayList<Integer>();
                            nowNode.add(nums[fixed1]);
                            nowNode.add(nums[fixed2]);
                            nowNode.add(nums[first]);
                            nowNode.add(nums[last]);
                            result.add(nowNode);
                        }
                        
                        
                        first++;
                        last--;
                    }
                }
                
                fixed2++;
                
            }
            fixed1++;
        }
        
        return result;
        
    }
}

第二次 82ms:

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        Arrays.sort(nums);
        for(int i = 0; i < nums.length; i++){
           for(int j = i + 1; j < nums.length; j++){
               int sum = (nums[i] + nums[j]);
               int m = j + 1, n = nums.length - 1; 
               while(m < n){
                   sum += (nums[m]+nums[n]);
                   if(sum == target){
                       List<Integer> temp = Arrays.asList(nums[i], nums[j], nums[m], nums[n]);
                       if(!result.contains(temp)){
                           result.add(temp);
                       }
                       sum -= (nums[m] + nums[n]);
                       n--;
                   }else if(sum < target){
                       sum -= (nums[m] + nums[n]);
                       m++;
                   }else{
                       sum -= (nums[m] + nums[n]);
                       n--;
                   }
               }
           } 
        }
        return result;
    }
    
}