专题一 - 双指针 - leetcode 18. 四数之和 - 中等难度

leetcode 18. 四数之和 | 中等

1. 题目详情

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

0 <= a, b, c, d < n
$a、b、c和d互不相同$
$nums[a]+nums[b]+nums[c]+nums[d]==target$
你可以按 任意顺序 返回答案 。

示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：
输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

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

1. 原题链接

leetcode 18. 四数之和

2. 基础框架

● Cpp代码框架

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {

    }
};

2. 解题思路

leetcode 15. 三数之和 题解

1. 题目分析

$(1)$ 本题要找数组nums中四个不同位置的数，且满足$nums[a]+nums[b]+nums[c]+nums[d]==target$，每四个数为一组的结果中，组与组之间不能重复。如果你做过三数之和你会直接发现应该如何做，可以戳上三数之和的题解链接查看解析。
转化为nums[a]+nums[b]+nums[c]=target-nums[d]，是求三数之和；
转化为nums[a]+nums[b]=target-nums[c]-nums[d]，是求两数之和；

2. 算法原理

$(1)$ 暴力解法：四层for循环，尝试每一种情况，时间复杂度$O(n^4)$，不考虑。
$(2)$ 思路与三数之和完全相同，只是再多一层for循环用于确定第二个数。详解见三数之和。

3. 时间复杂度

$O(n^3)$

比三数之和（时间复杂度$O(n^2)$）多加了一层循环

3. 代码实现

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
    	// 排序
        sort(nums.begin(), nums.end());
        vector<vector<int>> vvi;
        int n = nums.size();
        for(int i = 0; i < n - 1; ){
        	// 确定第一个数
            for(int j = i + 1; j < n - 1;){
            	// 确定第二个数
                int l = j + 1, r = n - 1;
                while(l < r){
                	// 转化为两数之和的双指针算法
                    int sum = nums[l] + nums[r];
                    // 这里处理int越界的问题，使用long long
                    long long newtarget = (long long)target - nums[i] - nums[j];
                    if(sum > newtarget ){
                        r--;
                    }
                    else if(sum < newtarget ){
                        l++;
                    }
                    else{
                        vvi.push_back({nums[i], nums[j], nums[l], nums[r]});
                        // left和right去重
                        l++;
                        r--;
                        while(l < r && nums[l] == nums[l - 1]) l++;
                        while(l < r && nums[r] == nums[r + 1]) r--;
                    }
                }
                // nums[j]去重
                j++;
                while(j < n && nums[j] == nums[j - 1]) j++;
            }
            // nums[i]去重
            i++;
            while(i < n && nums[i] == nums[i - 1]) i++;
        }
        return vvi;
    }
};

---

$The$ $End$