LeetCode - 15. 三数之和

最新推荐文章于 2021-10-09 21:17:29 发布

klbc

最新推荐文章于 2021-10-09 21:17:29 发布

阅读量124

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法 c++

本文链接：https://blog.csdn.net/u010323563/article/details/113357942

版权

LeetCode 专栏收录该内容

85 篇文章 0 订阅

订阅专栏

掉坑总结：方法三中，排序+双指针实现，有两个地方搞了好久

1）在循环k位置的时候，即要保证每个不同的元素（位置k）都被使用到，又要保证不要使用重复的元素，即第一次出现的不同元素需要使用，所以用的是当前k 和上一个元素 k-1比较。

                // 跳过和前面相等的元素，避免重复解，注意，这儿要保证元素第一次出现的时候被使用一次，和下面的 l, r 有所区别
                if (k > 0 && nums[k] == nums[k - 1]) {
                    continue;
                }

2）在位置k确定的情况下，l=k+1, r=n-1两个指针对撞中，因为初始l,r肯定被使用了，被用来做求和了，所以，三种情况（sum >0, <0, ==0）下都需要跳过重复的元素，这个时候需要拿下一个元素（l后一个，r前一个）来比较是否跟当前的l/r相同，所以需要直接递进l/r的值进行比较，肯定不能是nums[l+1] == nums[l]，如果这样比较，跳出循环后l还是在相同元素的最后一个位置，因为nums[l+1] != nums[l]，但是l还是指向最后一个相同元素，那就进入死循环了。

                while (l < r) {
                    int sum = nums[k] + nums[l] + nums[r];
                    if (sum < 0) {
                        // 跳过已经被枚举过的元素，注意，这儿初始l位置元素已经被使用过一次，需要直接跳到下一个和初始l位置元素不同的元素
                        while (l < r && nums[l] == nums[++l]) {}
                    }
                    if (sum > 0) {
                        // 跳过已经被枚举过的元素，注意，这儿初始r位置元素已经被使用过一次，需要直接跳到下一个和初始r位置元素不同的元素
                        while (l < r && nums[r] == nums[--r]) {}

                    }
                    if (sum == 0) {
                        res.push_back(vector<int>{nums[k], nums[l], nums[r]});
                        while (l < r && nums[l] == nums[++l]) {} // 同上
                        while (l < r && nums[r] == nums[--r]) {} // 同上
                    }
                }

描述

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

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：

输入：nums = []
输出：[]
示例 3：

输入：nums = [0]
输出：[]

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum/

求解

    class Solution {
    public:
        // 方法一，通过O(N*N)复杂度存储了两个数和以及下标的映射集合，再通过遍历单个元素搜索
        // 超时未通过，O(N*N*N)
        vector<vector<int>> threeSum_1e(vector<int> &nums) {
            const int n = nums.size();
            // 构造任意两数和的映射集合
            std::unordered_multimap<int, std::vector<int>> record; // <num1 + num2, {num1位置下标, num2位置下标}>映射集合
            for (int i = 0; i < n; ++i) {
                for (int j = i + 1; j < n; ++j) {
                    record.emplace(nums[i] + nums[j], std::move(vector<int>{i, j}));
                }
            }

            // 对每个数num，在记录中寻找0-num是否存在，若存在则为一个解
            std::set<std::vector<int>> midRes; // 使用set方便去重
            for (int index = 0; index < n; ++index) {
                auto[iterBegin, iterEnd] = record.equal_range(0 - nums[index]);
                if (iterBegin != iterEnd) {
                    for (auto iter = iterBegin; iter != iterEnd; ++iter) {
                        int index1 = iter->second[0];
                        int index2 = iter->second[1];  // 因为确定里面只有两个元素
                        if (index != index1 && index != index2) {
                            // 确保当前遍历的元素和记录中的不重复
                            vector<int> values{nums[index], nums[index1], nums[index2]};
                            std::sort(values.begin(), values.end());
                            midRes.emplace(std::move(values));
                        }
                    }
                }
            }

            // 整理全部结果
            vector<vector<int>> res;
            for (auto &rec : midRes) {
                res.emplace_back(std::move(rec));
            }
            return res;
        }

        // 方法二，仅存一个元素和下标的映射集合，通过O(n*n)的方式遍历
        // 超时未通过，不过较第一种方法有提高，O(N*N*N)
        vector<vector<int>> threeSum_2e(vector<int> &nums) {
            const int n = nums.size();
            // 构造任意两数和的映射集合
            std::unordered_multimap<int, int> record; // <num, num>映射集合
            for (int i = 0; i < n; ++i) {
                record.emplace(nums[i], i);
            }


            std::set<vector<int>> midRec; // 使用set去重，比如[-1,0,1] 和 [0,-1,1]是同一个答案
            vector<vector<int>> res;
            for (int i = 0; i < n - 1; ++i) {
                for (int j = i + 1; j < n; ++j) {
                    auto[is, ie] = record.equal_range(0 - nums[i] - nums[j]);
                    if (is == ie) {
                        continue;
                    }
                    for (auto iter = is; iter != ie; ++iter) {
                        int k = iter->second;
                        if (k > i && k > j) {
                            // 确保i,j,k三个下标合法有效，即三个下标均不重复
                            vector<int> group{nums[i], nums[j], nums[k]};
                            std::sort(group.begin(), group.end());
                            if (midRec.count(group) == 0) {
                                // 如果在set集合中不存在该组合，则添加到结果中
                                midRec.insert(group);
                                res.push_back(std::move(group));
                            }
                        }
                    }
                }
            }
            return res;
        }

        // 方法三，排序+双指针, O(N*LOGN)排序， 循环为O(N*N), 时间复杂度为O(N*N)
        // 通过
        vector<vector<int>> threeSum(vector<int> &nums) {
            const int n = nums.size();
            std::sort(nums.begin(), nums.end());
            vector<vector<int>> res;
            for (int k = 0; k < n - 2; ++k) {
                // 当前位置已经大于0，其后的元素肯定大于0，不可能再找到解
                if (nums[k] > 0) {
                    break;
                }
                // 跳过和前面相等的元素，避免重复解，注意，这儿要保证元素第一次出现的时候被使用一次，和下面的 l, r 有所区别
                if (k > 0 && nums[k] == nums[k - 1]) {
                    continue;
                }
                int l = k + 1;
                int r = n - 1;
                while (l < r) {
                    int sum = nums[k] + nums[l] + nums[r];
                    if (sum < 0) {
                        // 跳过已经被枚举过的元素，注意，这儿初始l位置元素已经被使用过一次，需要直接跳到下一个和初始l位置元素不同的元素
                        while (l < r && nums[l] == nums[++l]) {}
                    }
                    if (sum > 0) {
                        // 跳过已经被枚举过的元素，注意，这儿初始r位置元素已经被使用过一次，需要直接跳到下一个和初始r位置元素不同的元素
                        while (l < r && nums[r] == nums[--r]) {}

                    }
                    if (sum == 0) {
                        res.push_back(vector<int>{nums[k], nums[l], nums[r]});
                        while (l < r && nums[l] == nums[++l]) {} // 同上
                        while (l < r && nums[r] == nums[--r]) {} // 同上
                    }
                }
            }
            return res;
        }
    };