leetcode之hot100---三数之和（C++）

本题的难点为去除重复值

思路：借助双指针在将三数之和问题转化为两数之和问题 

• 对数组进行排序，方便双指针的使用
• 固定一个数 nums[i]。
• 使用双指针在剩余数组中查找两个数，使得三数之和为 0。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
       
        vector<vector<int>> result;//存放结果的二维向量

        sort(nums.begin(), nums.end());//对数组进行排序，方便双指针的使用
        //ranges::sort(nums);
        
        for(int i = 0; i < nums.size(); i++){
            //去重操作1
            if (i > 0 && nums[i] == nums[i - 1]) continue; // 跳过重复的nums[i]
            int left = i + 1, right = nums.size() - 1;//定义左右指针位置
            while(left < right){
                if(nums[i] + nums[left] + nums[right] == 0){
                    result.push_back({nums[i],nums[left],nums[right]});
                    //去重操作2
                    while (left < right && nums[left] == nums[left + 1]) ++left;
                    while (left < right && nums[right] == nums[right - 1]) --right;
                    //查找其他符合条件的三元组
                    left++;
                    right--;
                }
                 else if (nums[i] + nums[left] + nums[right] < 0) {
                    ++left; // 增大总和
                } else {
                    --right; // 减小总和
                }
                
            }
        }
        
        return result;
    }
};

假设

nums = [-1,0,1,2,-1,-4]
先对其排序得到nums = [-4,-1,-1,0,1,2]

经过一个while循环可以得到满足情况的三元组为[[-1,-1,2],[-1,0,1]]

去重操作 2（while 循环内部的去重）

当我们已经找到一个满足条件的三元组（比如 [-1, -1, 2]），我们希望避免重复找到这个结果。因此，在固定当前的第一个数 -1 时：

• 如果左指针指向的值（nums[left]）和它右边的值相同（nums[left] == nums[left + 1]），我们直接跳过重复值，右移左指针。

• 如果右指针指向的值（nums[right]）和它左边的值相同（nums[right] == nums[right - 1]），我们直接跳过重复值，左移右指针。

这样可以确保 在固定第一个数的情况下，不会重复找到相同的三元组。例如，在找到 [-1, -1, 2] 后，不会再次找到重复的 [-1, -1, 2]。

去重操作 1（for 循环的去重）

当我们已经完成了以 nums[i] = -1 为第一个数的所有三元组查找后（得到 [[-1, -1, 2], [-1, 0, 1]]），我们希望避免重复固定相同的数作为第一个数。因此：

• 如果当前的 nums[i] 和前一个数相同（nums[i] == nums[i - 1]），我们直接跳过，避免再次以 nums[i] = -1 为第一个数进行查找。

这样可以确保 在整体循环中，不会重复生成以同一个数为第一个数的所有三元组。例如，在已经完成以 -1 为第一个数的查找后，不会重复进入查找并再次生成 [[-1, -1, 2], [-1, 0, 1]]。

但是上述代码存在重复计算的情况，优化后的代码如下：

下述代码具体思路为：

• 排序：先对数组排序。
• 固定一个数 aaa：外层循环固定三元组中的第一个数。
• 双指针寻找 bbb 和 ccc：内层用双指针在剩余的数组中寻找符合条件的两个数。
• 去重：通过跳过相邻相同元素，避免结果重复。
• 收集结果：将所有满足条件的三元组存入结果集并返回。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];
            // 枚举 b
            for (int second = first + 1; second < n; ++second) {
                // 需要和上一次枚举的数不相同
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                // 需要保证 b 的指针在 c 的指针的左侧
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                // 如果指针重合，随着 b 后续的增加
                // 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    ans.push_back({nums[first], nums[second], nums[third]});
                }
            }
        }
        return ans;
    }
};