18. 4Sum（四数之和）4种解法（C++ & 注释）

1. 题目描述

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

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

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

题目链接：中文题目；英文题目

2. 暴力解法（Brute Force, Time Limit Exceeded）

直接三个for循环检查所有三元组是否符合题意，这种方法和3Sum题目的暴力解法差不多思路，代码可以参考一下，就不单独列举代码了。

3. 哈希表法（Hash Table, Time Limit Exceeded）

3.1 解题思路

哈希表法（Hash Table）的解题思路可以参考3Sum题目的解法。不幸的是，这种方法超时了。

3.2 实例代码

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());

        int len = nums.size();
        for (int i = 0; i < len; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) continue; // 跳过i代表的重复数字
            for (int j = i + 1; j < len; j++) {
                if (j != i + 1 && nums[j] == nums[j - 1]) continue; // 跳过j代表的重复数字
                unordered_map<int, int> m;
                for (int k = j + 1; k < len; k++) {
                    int complement = target - nums[i] - nums[j] - nums[k];
                    if (m.count(complement)) {
                        ans.push_back({ nums[i], nums[j], nums[k], complement });
                        while (k + 1 < len && nums[k] == nums[k + 1]) k++; // 有一个答案以后，跳过k代表的重复数字
                    }
                    else m.insert(pair<int, int>(nums[k], k)); // 需要保存k涉及到的所有数字，方便后面查找
                }
            }
        }

        return ans;
    }
};

4. 双指针法（Two Pointers）

4.1 解题思路

双指针法（Two Pointers）的解题思路可以参考3Sum题目的解法。

4.2 实例代码

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());

        int len = nums.size();
        for (int i = 0; i < len; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) continue; // 跳过i代表的重复数字
            for (int j = i + 1; j < len; j++) {
                if (j != i + 1 && nums[j] == nums[j - 1]) continue; // 跳过j代表的重复数字
                int left = j + 1, right = len - 1;
                while (left < right) {
                    if (nums[i] + nums[j] + nums[left] + nums[right] == target) {
                        ans.push_back({ nums[i], nums[j], nums[left], nums[right] });
                        left++;
                        right--;
                        while (left < right && nums[left] == nums[left - 1]) left++; // 跳过左边界重复数字
                        while (left < right && nums[right] == nums[right + 1]) right--; // 跳过右边界重复数字
                    }
                    else if (nums[i] + nums[j] + nums[left] + nums[right] > target) right--;
                    else left++;
                }
            }
        }

        return ans;
    }
};

5. 二分查找（Binary Search）

5.1 解题思路

二分查找（Binary Search）的解题思路可以参考3Sum Closest题目的解法。

只是这里用到了二分精确查找某个数：binary_search(first, last, target)是二分查找函数需要引入头文件#include ，查找范围为[first, last)，找到返回true，否则返回false。

5.2 实例代码

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());

        int len = nums.size();
        for (int i = 0; i < len; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) continue; // 跳过i代表的重复数字
            for (int j = i + 1; j < len; j++) {
                if (j != i + 1 && nums[j] == nums[j - 1]) continue; // 跳过j代表的重复数字
                for (int k = j + 1; k < len; k++) {
                    if (k != j + 1 && nums[k] == nums[k - 1]) continue; // 跳过k代表的重复数字
                    int complement = target - nums[i] - nums[j] - nums[k]; 
                    if (binary_search(nums.begin() + k +1, nums.end(), complement))) ans.push_back({ nums[i], nums[j], nums[k], complement });
                }
            }
        }

        return ans;
    }
};