LeetCode 18 - 四数之和（双指针法）

题目链接https://leetcode-cn.com/problems/4sum/comments/题目：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）        Given an array nums of n integers, return an array of all the unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that:

0 <= a, b, c, d < n
a、b、c 和 d 互不相同        a, b, c, and d are distinct.
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案        You may return the answer in any order.

---

Example 1:

Input: nums = [1,0,-1,0,-2,2], target = 0
Output: [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

---

Example 2:

Input: nums = [2,2,2,2,2], target = 8
Output: [[2,2,2,2]]  

---

Constraints:

1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

---

思路：

朴素的思路很简单，直接枚举即可，复杂度是，当然，在这道题朴素的解法一定不是我们的努力目标。

联系之前做过的“两数之和”与”三数之和“想到双指针法。简单而言就是先将数组排序，然后设置四个指针分别在数组的两端。左端的两个指针只能向右端移动，而右端的指针反之。(如果某个时刻四个指针所指数之和小于target，则让左边指针右移：先让最左的指针右移，直到和第二左的指针相邻为止。但是这是错误的思路，因为这可能会遗漏某些情况...)正确的思路是，枚举最两端两个指针的位置，然后对于中间的两个指针再考虑双指针法。

---

代码：(vector 不能指针？）

暂时没有一个AC的代码，我是菜逼，以后会完成滴

没有AC的原因是最后大数溢出的测试通不过，总是会出现溢出

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        long len=nums.size();
        vector<vector<int>> answer;
        if(len<4){
            return answer;
        }
        sort(nums.begin(),nums.end());
        //if(nums[0]>target && target>=0) return answer;

        for(long long i=0;i<len;i++) cout<<nums[i]<<" ";
        cout<<endl;
        long long p1=0,p2=1,p3=len-2,p4=len-1;
        long long t1, t2, t3, t4;
        for(p1=0;p1<len;){
            for(p4=len-1;p4>=0;){
                cout<<"check "<<p1<<" "<<p4<<endl;                
                p2=p1+1,p3=p4-1;
                if(p2>=p3 ) break;
                while(p2<p3){ cout<<p2<<" "<<p3<<endl;  
                    if((target-nums[p1]-nums[p2])==(nums[p3]+nums[p4])){
                        vector<int> cur_ans;
                        cur_ans.push_back(nums[p1]), cur_ans.push_back(nums[p2]);
                        cur_ans.push_back(nums[p3]), cur_ans.push_back(nums[p4]);
                        answer.push_back(cur_ans);
                        t2=p2, t3=p3;
                        while(p2<p3 && nums[t2]==nums[p2] && nums[t3]==nums[p3]){   
                        // change the index until the num is different...
                            p2++;   p3--;
                        }
                   }
                    else if((target-nums[p1]-nums[p2])>(nums[p3]+nums[p4])){p2++;}
                    else if((target-nums[p1]-nums[p2])<(nums[p3]+nums[p4])){p3--;}
                }
                t4=p4;
                while(p4>=0 && nums[p4]==nums[t4]) p4--;
            }
            t1=p1;
            while(p1<len && nums[p1]==nums[t1]) p1++;
        }
        return answer;
    }
};

附上力扣官网的算法，非常快，有空研究一下区别何在...

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> quadruplets;
        if (nums.size() < 4) {
            return quadruplets;
        }
        sort(nums.begin(), nums.end());
        int length = nums.size();
        for (int i = 0; i < length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) 
                continue;
            if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) 
                break;
            if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) 
                continue;

            for (int j = i + 1; j < length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
                if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) break;
                if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) continue;

                int left = j + 1, right = length - 1;
                while (left < right) {
                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        quadruplets.push_back({nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1]) 
                            left++;

                        left++;
                        while (left < right && nums[right] == nums[right - 1]) 
                            right--;
                        right--;
                    } else if (sum < target) 
                        left++;
                    else 
                        right--;
                }
            }
        }
        return quadruplets;
    }
};

姑且先这样吧！