18. 4Sum（双指针 注意答案去重）

---

Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums 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.

Example:

Given array nums = [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]
]

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums = sorted(nums)
        n = len(nums)
        res = []
        for i in range(n-3):
            if i>0 and nums[i]==nums[i-1]:
                continue
            for j in range(i+1,n-2):
                if j > i+1 and nums[j] == nums[j-1]:
                    continue
                l = j+1
                r = n-1
                while l < r:
                    cur = nums[i]+nums[j]+nums[l]+nums[r]
                    if cur > target:
                        r-=1
                    elif cur < target:
                        l+=1
                    else:
                        res.append([nums[i],nums[j],nums[l],nums[r]])
                        while l < r and nums[l]==nums[l+1]:l+=1
                        while l < r and nums[r]==nums[r-1]:r-=1
                        l+=1
                        r-=1
        return res

 

 

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        if(nums.size() < 4) return res;
        sort(nums.begin(),nums.end());
        for(int i = 0;i < nums.size() - 3;++i) {
            if (i!=0 && nums[i]==nums[i-1]) continue; // 去重
            for(int j = i+1;j < nums.size() -2;++j) {
                if(j!= i+1 && nums[j]==nums[j-1]) continue;//去重
                int low = j + 1;
                int high = nums.size() -1;
                while(low < high) {
                    int sum = nums[i] + nums[j] + nums[low] + nums[high];
                    if (sum == target) {
                        res.emplace_back(vector<int>({nums[i],nums[j],nums[low],nums[high]}));
                        while(low < high && nums[low]==nums[low+1]) low++;  // 去重
                        while(low < high && nums[high]==nums[high-1]) high--; // 去重
                        high--;
                        low++;
                    } else if (sum > target) {
                        high--;
                    } else if (sum < target) {
                        low++;
                    }
                }
            }
        }
        return res;
    }
};

 

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new LinkedList<>();
        if (nums.length<4) return res;
        Arrays.sort(nums);
        for(int i=0;i<nums.length-3;i++){
            if(i>0&&nums[i]==nums[i-1]) continue;
            for(int j=i+1;j<nums.length-2;j++){
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                
                int lo = j+1,hi = nums.length-1;
                while(lo<hi){
                    int sum = nums[i]+nums[j]+nums[lo]+nums[hi];
                    if(sum==target){
                        res.add(Arrays.asList(nums[i],nums[j],nums[lo],nums[hi]));
                       
                        //答案去重
                        while(lo<hi&&nums[lo]==nums[lo+1])  lo++;
                        while(lo<hi&&nums[hi]==nums[hi-1])  hi--;
                        
                        lo++;
                        hi--;
                    }
                    
                    else if(sum<target) lo++;
                    else hi--;
                }
               
            }
        }
        return res;
    }
}