2022-1-13 LeetCode N数之和（双指针+去重）

一、两数之和（经典第一题）

1. 暴力法
   时间 O（n^2）

2. 排序后双指针法
   时间O(nlogn)
   空间O（1）

3. 哈希表法
   时间O（n）
   空间O（n）

这题的要求是在于会写哈希表法。
知识点有：unordered_map, find方法。（有一说一，不使用find方法想要写清楚的代码还是挺难的）

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> mp;//存的数字，下标
        int n=nums.size();
        for(int i=0;i<n;i++)
        {
            auto it=mp.find(target-nums[i]);
            if(it!=mp.end())
            {
                return vector<int>{i,it->second};
            }

            mp[nums[i]]=i;
        }

        return vector<int>{0,0};

    }
};

15. 三数之和

这题则不推荐哈希写法了，哈希写法要先确定a，b，然后寻找target-a-b，时间复杂度O（n^2）

使用双指针法，通解三数之和O(n^2)、 四数之和O(n^3)…
在使用双指针前，显然需要排序 O（nlogn） 对于两数之和来说这个复杂度相比哈希高了一丢丢，但是这个复杂度与此时的哈希写法相比，可以约去了^^
除此之外，第一题要求的是返回下标，经过排序以后，下标已经不是原来的下标了，所以不能使用。

这题最难的还是如何去重…

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int n=nums.size();
        vector<vector<int>> res;
        vector<int> temp;
        int sum,left,right;

        for(int i=0;i<n;i++)
        {
            left=i+1;
            right=n-1; //[left,right]
            if(left>=n) break;
            if(i>0&&nums[i]==nums[i-1]) continue; //去重

            while(left<right) //虽然是左闭右闭 但是同一个位置的数字只能用一次啊！！！
            {
                if(nums[i]+nums[left]+nums[right]==0)
                {
                    temp.push_back(nums[i]);
                    temp.push_back(nums[left]);
                    temp.push_back(nums[right]);
                    res.push_back(temp);
                    //可以改为 res.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    temp.clear();

					//左右位置去重
                    while(right>left&&nums[right]==nums[right-1]) right--;
                    while(right>left&&nums[left]==nums[left+1]) left++;

                    left++;right--; //找到一组，同时收缩，因为这两个位置已经用过了，不能再用

                }
                else if(nums[i]+nums[left]+nums[right]<0)
                {
                    left++;
                }
                else right--;
            }

            

        }

        return res;



    }
};

18. 四数之和

while(i>0&&i<n&&nums[i]==nums[i-1]) i++;//如果用while来去重的话，请务必加上i<n 以下同理（否则访问非法内存了，下标越界）

也可以if+continue，借助外层for去重

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());
        int n=nums.size();
        if(n<4) return res;
        int left,right;


        for(int i=0;i<n;i++)
        {
            while(i>0&&i<n&&nums[i]==nums[i-1]) i++;  //如果用while来去重的话，请务必加上i<n 以下同理（否则访问非法内存了，下标越界）
            for(int j=i+1;j<n;j++)
            {
                while(j>i+1&&j<n&&nums[j]==nums[j-1]) j++;
                left=j+1,right=n-1;
                if(left>=n) break;
                while(left<right)
                {
                    long long sum=(long long)nums[i]+(long long)nums[j]+(long long)nums[left]+(long long)nums[right];
                    if(sum==target)
                    {
                        res.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});

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

            }
        }

return res;


    }
};