三数之和与最接近的三数之和

三数之和与最接近的三数之和

原文链接

三数之和

原题链接

题目

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

示例

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

分析

若使用暴力枚举，需要枚举三个元素的所有可能组合，而且需要考虑是否会导致重复，时间复杂度高达$O(n^3)$。

要求没有重复的三元组，而解决重复的方法自然时排序。因此，第一步就是原数组进行排序，在选择三元组每一个元素的过程中就可以跳过前后重复的元素来进行去重。

此时复杂度并没有降低，但是排序后提供了一个新思路。因为数组是有序的，这是我们就可以引进双指针一些优化。算法思路是：

• 遍历排序后的数组，设索引下标为$i=0\to len-1$($len$为数组大小)

• 对于当前索引$i$，表示三元组中的第一个元素，设$l=i+1$，表示第二元素的初始值，设$r=len-1$表示第三个元素的初始值

  • 若$nums[i]>0$，直接返回答案，因为后面的数只会更大，其和只能会更大不可能为0
  • 若$nums[i]==nums[i-1]$，跳过，避免重复

• 当$l<r$时循环，记$sum=nums[i]+nums[l]+nums[r]$

  • 若$sum==0$，则将当前的三个数字加入答案中
  • 若$sum>0$，则说明和大了，此时应该减少第三个元素的值，即$r=r-1$
  • 若$sum<0$，则说明和小了，此时应该增加第二个元素的值，即$l=l+1$

  注意，上面的三个过程均需要针对$l$和$r$跳过重复元素

代码

class Solution {
    
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int len = nums.size();
        vector<vector<int>> ans;
        if (len < 3)
            return ans;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < len - 2; i++) {
            if (nums[i] > 0)
                return ans;
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            int l = i + 1;
            int r = len - 1;
            while (l < r) {
                int sum = nums[i] + nums[l] + nums[r];
                if (sum == 0) {
                    vector<int> temp = {nums[i], nums[l], nums[r]};
                    ans.push_back(temp);
                    while (l < r && nums[l] == nums[l + 1]) l++;
                    while (l < r && nums[r] == nums[r - 1]) r--;
                    l++;
                    r--;
                } else if (sum > 0) {
                    while (l < r && nums[r] == nums[r - 1]) r--;
                    r--;
                } else {
                    while (l < r && nums[l] == nums[l + 1]) l++;
                    l++;
                }
            }
        }
        return ans;
    }
};

最接近的三数之和

题目

原题链接

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.

与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

分析

这题思路和上面的题目一样，依旧先对原数组排序，然后遍历设置双指针

• 遍历排序后的数组，设$ans=nums[0]+nums[1]+nums[2]$，设索引下标为$i=0\to len-1$($len$为数组大小)

• 对于当前索引$i$，表示三元组中的第一个元素，设$l=i+1$，表示第二元素的初始值，设$r=len-1$表示第三个元素的初始值

  • 若$nums[i]==nums[i-1]$，跳过，避免重复计算

• 当$l<r$时循环，记$sum=nums[i]+nums[l]+nums[r]$

  • 若$|sum-target|<|ans-target|$，则更新$ans=sum$

  • 若$sum>target$，则说明和大了，此时应该减少第三个元素的值，即$r=r-1$

  • 若$sum<target$，则说明和小了，此时应该增加第二个元素的值，即$l=l+1$

  • 若$sum==target$，则直接返回$sum$

代码

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int len = nums.size();
        sort(nums.begin(), nums.end());
        int ans = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < len - 2; i++) {
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            int l = i + 1;
            int r = len - 1;
            while (l < r) {
                int sum = nums[i] + nums[l] + nums[r];
                if (abs(sum - target) < abs(ans - target)) {
                    ans = sum;
                }
                if (sum > target) {
                    r--;
                } else if (sum < target) {
                    l++;
                } else {
                    return ans;
                }
            }
        }
        return ans;
    }
};