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 {
 public:
     vector<vector<int>> fourSum(vector<int>& a, int target) {
     vector<vector<int>> res;
     const int n = a.size();
     if (n < ) return res;
     std::sort(a.begin(),a.end());
     for (int i = ; i < n-; ++i) {
         if(i!= && a[i]==a[i-]) {continue;} //去重
         for (int j = i+; j < n-; ++j) {
             if(j!=i+ && a[j]==a[j-]){continue;} //去重
             int low = j+;
             int high = n-;
             while (low < high) {
                 int sum = a[i]+a[j]+a[low]+a[high];
                 if (sum > target) {
                     high--;
                 } else if (sum < target) {
                     low++;
                 } else {
                     vector<int> tep = {a[i],a[j],a[low],a[high]};
                     res.emplace_back(tep);
                     while(low <high && a[low]==a[low+]) {low++;}//去重
                     while(low <high && a[high]==a[high-]) {high--;}//去重
                     low++;
                     high--;
                 }
             }

         }
     }
     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;
     }
 }