力扣日记9.10-【哈希表篇】三数之和

力扣日记：【哈希表篇】三数之和

日期：2023.9.10（摆，狠狠摆aaa）
参考：代码随想录、力扣

15.三数之和

题目描述

难度：中等

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

3 <= nums.length <= 3000
-105 <= nums[i] <= 105

题解

class Solution {
#define SOLUTION 2
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
#if SOLUTION == 1
        // 三数之和，分为两数+一数
        // 哈希法，超过时间限制了
        int size = nums.size();
        multimap<int, int> record;
        vector<multiset<int>> ans;
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (i == j) {
                    // record.insert(make_pair(nums[i], i));
                    record.insert(make_pair(nums[i], i));
                    continue;
                }
                int want = 0 - nums[i] - nums[j];
                auto range = record.equal_range(want);
                if (range.first != record.end()) {  
                    for (auto it = range.first; it != range.second; ++it) {
                        if(it->second != i && it->second != j) {
                            // 符合条件
                            // 但是存储时如何去重呢？
                            multiset<int> seti; // 有序(按哈希值?)，可重复
                            seti.insert(nums[i]);
                            seti.insert(nums[j]);
                            seti.insert(want);
                            
                            // 检查每个 multiset 是否已经存在于 vector 中
                            if (find(ans.begin(), ans.end(), seti) == ans.end()) { // 太费时了
                                ans.push_back(seti); // 去重
                                // 只会存储唯一的 multiset，重复的 multiset 不会被添加。
                                // 需要注意的是，这里比较的是 multiset 的内容，不考虑元素的顺序。
                            }
                        }
                    }
                }
            }
        }
        vector<vector<int>> real_ans;
        for (const auto& multiset : ans) {
            vector<int> tempVector(multiset.begin(), multiset.end());
            real_ans.push_back(tempVector);
        }
        return real_ans;
#elif SOLUTION == 2
        // 双指针法
        // 设三元组中的三个数为a,b,c：a通过for循环遍历，b,c分别用left指针和right指针遍历
        vector<vector<int>> result;
        // 首先进行排序(这样使得左边小，右边大，则为了让和为0，指针需往对应方向移动)
        sort(nums.begin(), nums.end());
        // 对a进行遍历
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > 0) { // 则不可能和为0了
                return result;
            }
            // 对 a 进行去重
            if (i > 0 && nums[i] == nums[i - 1]) { // 与上一个数相同，则跳过（-1, -1, 2，如遍历到第二个-1，即使下一个数是2，这个三元组肯定在遍历到第一个-1就得到了）
                continue;
            }
            // 接下来对b c 即left right进行遍历
            int left = i + 1;
            int right = nums.size() - 1;
            while (left < right) {
                if (nums[i] + nums[left] + nums[right] == 0) {
                    result.push_back({nums[i], nums[left], nums[right]});
                    // 再找到一组三元组之后，再去重left right
                    while (left < right && nums[left+1] == nums[left]) {
                        left++;
                    }
                    while (left < right && nums[right-1] == nums[right]) {
                        right--;
                    }
                    left++;
                    right--;
                } else if (nums[i] + nums[left] + nums[right] > 0) {
                    // 大了，则right向左移动使得right变小
                    right--;
                } else {
                    // 小了，则left向右移动
                    left++;
                }

            }
        }
        return result;
#endif
    }
};

复杂度

我的哈希法：

超出时间限制了

代码随想录的哈希法

时间复杂度： O(n^2)
空间复杂度：O(n)

代码随想录的双指针法

时间复杂度：O(n^2)
空间复杂度：O(1)

思路总结

• 双指针法
  • 使用条件：本题返回不要求数组下标，仅要求元素值，因此可以对数组进行排序，才可以用双指针法
  • 其实是三指针，分别对应三元组中的三个数a b c，a通过for循环遍历，b和c则是在a固定时，通过left和right进行遍历
  • left指针向右，right指针向左：通过先对数组进行排序，使得左小右大，则在对b和c进行遍历时，通过判断和＞0还是<0，使得对应的right左移（和减小）或者left右移（和变大）。
  • 去重很关键
    • 对a的去重：每次遍历a时，判断是否与上一个值相同，若相同，则跳过当前循环（比如遇到三元组-1, -1, 2，在遍历到第二个-1，即使下一个数是2，这个三元组肯定在遍历到第一个-1就得到了）
    • 对b和c的去重：需要在存储了至少一组三元组后才去重（否则{0，0，0}会丢失），其中left与下一个值比较；right与上一个值比较
• 哈希法：
  • 在对三元组去重时费时太多，超出时间限制了
  • 代码随想录的还没看懂www