C++四数之和

C++四数之和

  给你一个由 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

思路/解法

方式一

使用回溯算法，暴力穷举即可。但是时间复杂度过高。

class Solution {
public:
    void Traceback(vector<int>& nums, int start, int sum, int target, vector<int>& back,vector<vector<int>>& res, vector<int>& visited)
    {
        if(4 == back.size() && sum == target)
        {
            res.push_back(back);
            return;
        }

        for(int i = start;i < nums.size();i++)
        {
            if(1 == visited[i] || (i > 0 && nums[i] == nums[i - 1] && visited[i - 1] == 0))
            {
                continue;
            }
            
            visited[i] = 1;
            back.push_back(nums[i]);
            sum       += nums[i];
            Traceback(nums, i + 1, sum, target, back, res, visited);
            visited[i] = 0;
            back.pop_back();
            sum       -= nums[i];
        }
    }

    vector<vector<int>> fourSum(vector<int>& nums, int target) 
    {
        vector<vector<int>> res;
        vector<int>         back;
        std::vector<int>    visited(nums.size(), 0);
        std::sort(nums.begin(),nums.end());
        Traceback(nums, 0, 0, target, back, res, visited);
        return res;
    }
};

方式二

两数遍历 + 双指针，使用简单遍历算法遍历两数出现的可能值（确定前两数），再使用双指针确定后两数即可。

TIPS：由于int类型可能溢出，在加减的过程中需要注意转化为long long类型。

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

			for (int j = i + 1; j < nums.size() - 2; j++)
			{
				if (j > i + 1 && nums[j] == nums[j - 1])
				{
					continue;
				}
				
				leftIndex  = j + 1;
				rightIndex = nums.size() - 1;
				
				while (leftIndex < rightIndex)
				{
					if ((long long)(nums[i] + nums[j] - (long long)target) > -(long long)(nums[leftIndex] + nums[rightIndex]))
					{
						rightIndex--;
					}
					else if ((long long)(nums[i] + nums[j] - (long long)target) < -(long long)(nums[leftIndex] + nums[rightIndex]))
					{
						leftIndex ++;
					}
					else
					{
						res.push_back({ nums[i], nums[j], nums[leftIndex], nums[rightIndex] });
						leftIndex ++;																	//缩小区间，继续查找
						rightIndex--;
						while (leftIndex < rightIndex && nums[leftIndex] == nums[leftIndex - 1])
						{
							leftIndex ++;
						}

						while (leftIndex < rightIndex && nums[rightIndex] == nums[rightIndex + 1])
						{
							rightIndex--;
						}
					}
				}
				
			}
		}
		return res;
    }
};