2021.8.2 力扣-四数之和

题目描述：

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：答案中不可以包含重复的四元组。

方法一：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;
        int n = nums.size();
        sort(nums.begin() , nums.end());
        for(int first=0 ; first<n-3 ; first++)
        {
            if(first>0 && nums[first] == nums[first-1])
            {
                continue;
            }
            for(int second=first+1 ; second<n-2 ; second++)
            {
                if(second>first+1 && nums[second] == nums[second-1])
                {
                    continue;
                }
                int fourth = n-1;
                long fs = nums[first] + nums[second];
                for(int third = second+1 ; third<n-1 ; third++)
                {
                    if(third>second+1 && nums[third] == nums[third-1])
                    {
                        continue;
                    }
                    while(third<fourth && fs+nums[third]+nums[fourth] > target)
                    {
                        fourth--;
                    }
                    if(third==fourth)
                    {
                        break;
                    }
                    if(fs+nums[third]+nums[fourth] == target)
                    {
                        ans.push_back({nums[first],nums[second],nums[third],nums[fourth]});
                    }
                }
            }
        }
        return ans;
    }
};

跟三数之和一样的做法，先排序后双指针法，注意有个样例为[1000000000, 1000000000, 1000000000, 1000000000] ，target=0，由于元素相加会超过int的范围上限，所以fs要用long型。

时间复杂度：O(n3)，空间复杂度：O(logn)

方法二：

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> mynums , subans;
    int mytarget , numsize;
    void DFS(int low , int sum)
    {
        if(subans.size()==4 && sum==mytarget)
        {
            ans.push_back(subans);
            return;
        }
        for(int i=low ; i<numsize ; i++)
        {
            if((numsize-i) < int(4-subans.size()))   //剩余可选元素个数少于还需的元素个数
            {
                return ;
            }
            if(i>low && mynums[i]==mynums[i-1])   //若有重复元素
            {
                continue;
            }
            if(i<numsize-1 && mynums[i]+sum+long(3-subans.size())*mynums[i+1] > mytarget)//剪枝
            {
                return;
            }
            if(i<numsize-1 && mynums[i]+sum+long(3-subans.size())*mynums[numsize-1] < mytarget)//剪枝
            {
                continue;
            }
            subans.push_back(mynums[i]);
            DFS(i+1 , sum+mynums[i]);
            subans.pop_back();          //删除mynums[i]，继续遍历
        }
        return ;
    }
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin() , nums.end());
        mynums = nums;
        numsize = nums.size();
        mytarget = target;
        if(numsize<4)
        {
            return ans;
        }
        DFS(0,0);
        return ans;
    }
};

运用了这位大佬的DFS回溯剪枝法：https://leetcode-cn.com/problems/4sum/solution/mei-kan-dao-ji-ge-hui-su-de-ti-jie-na-wo-lai-xie-y/，执行时间大大减少

该方法的剪枝是关键：

另外，代码中的(long)不能够去掉，一是由于vector的size()函数的返回类型是无符号整数，无符号整数不能够轻易取负数，例如无符号整数5取负：；二是由于样例中有[1000000000, 1000000000, 1000000000, 1000000000]，target=0，其元素相加将有可能超过int的取值范围上限。