LeetCode 15: 3Sum

3Sum^[1]

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note:

• Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
• The solution set must not contain duplicate triplets.

For example, given array S = {-1 0 1 2 -1 -4}, a solution set is: (-1, 0, 1)，(-1, -1, 2)。

解题思路

思路一：使用3层 for 循环，穷举所有符合条件的三元组（non-descending order）。由于原始输入数组本身可能包含重复元素，所以需要对选取到的三元组进行筛选移除重复三元组 。时间复杂度O(N³)，代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int numsLen = nums.size();

        vector<vector<int>> ret;
        for (int i = 0; i < numsLen; ++i) {
            for (int j = i + 1; j < numsLen; ++j) {
                for (int k = j + 1; k < numsLen; ++k) {
                    // 3层 for 循环，穷举所有符合条件的三元组
                    if (nums[i] + nums[j] + nums[k] == 0) {
                        vector<int> triplet({nums[i], nums[j], nums[k]});
                        // non-descending order
                        sort(triplet.begin(), triplet.end());
                        ret.push_back(triplet);
                    }
                }
            }
        }

        // 对选取到的三元组进行筛选移除重复三元组 
        sort(ret.begin(), ret.end(), less<vector<int>>());
        vector<vector<int> >::iterator new_end = unique(ret.begin(), ret.end());
        ret.erase(new_end, ret.end()); 

        return ret;
    }
};

思路二：可以对上述暴力解法做一些改进。题目要求选出的三元组是非递减的，所以先对输入数组进行排序；依然使用3层 for 循环，穷举所有符合条件的三元组（non-descending order）；因为数组已经有序，很容易在获取符合条件的三元组时就进行去重，而不用在求出所有的三元组之后再进行一次排序进行去重。时间复杂度依然是O(N³)。代码如下：

class Solution {  
public:  
    vector<vector<int> > threeSum(vector<int> &num) {  
        // 为了选出的三元组是非递减的，先对输入数组进行排序
        sort(num.begin(), num.end()); 

        vector<int> triplet; 
        vector<vector<int> > result; 
        size_t size = num.size();
        // 3层 for 循环，穷举所有符合条件的三元组
        for (size_t i = 0; i < size; i++) {  
            // 如果第一个元素已经大于目标0，则直接返回  
            if (num[i] > 0) {  
                break;  
            } 

            // 去重，如果当前第一个元素与上一次的第一个元素相同，则跳过该元素
            if (i > 0 && num[i] == num[i-1])  {  
                continue;  
            }  

            for (size_t j = i + 1; j < size; j++)  
            {  
                // 去重，如果当前第二个元素与上一次的第二个元素相同，则跳过该元素
                // 限制的是符合条件的三元组中的第二个元素，这里需要判断j>i+1，以避免与第一个元素比较  
                if (j > i+1 && num[j] == num[j-1])  
                {  
                    continue;  
                }  

                for (size_t k = j + 1; k < size; k++)  
                {  
                    // 去重，原理与上同  
                    if (k > j+1 && num[k] == num[k-1])  
                    {  
                        continue;  
                    }  

                    // 这里的符合条件的三元组已经经过了所有的去重处理，是最终结果中的一个  
                    if (num[i] + num[j] + num[k] == 0)  
                    {  
                        triplet.push_back(num[i]);  
                        triplet.push_back(num[j]);  
                        triplet.push_back(num[k]);  
                        result.push_back(triplet);  
                        triplet.clear();  
                    }  
                }  
            }  
        }  

        return result;  
    }  
};  

思路三：首先对数组进行排序。对于3Sum问题，我们可以先固定第一个数；然后找另外两个数之和为第一个数的相反数，这是一个2Sum，可以使用两个指针分别从数组的前后两端向中间扫描。因为数组是有序的，因此对于 num[i]，寻找另外两个数时，只要从 i+1 开始找就可以了。时间复杂度为O(N²)。

代码如下：

class Solution {  
public:  
    vector<vector<int> > threeSum(vector<int> &nums) {  
        int numsLen = nums.size();
        vector<int> triplet;
        vector<vector<int>> result;

        // 对数组排序
        sort(nums.begin(), nums.end()); 

        // 先固定第一个数；然后找另外两个数之和为第一个数的相反数
        for (int i = 0; i < numsLen; ++i) {
            // 第一个数去重
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }

            // 使用两个指针分别从数组的 i+1 和 numsLen-1 两端向中间扫描，解决2Sum问题
            int left = i + 1;
            int right = numsLen - 1;
            while (left < right) {
                if (nums[left] + nums[right] == -nums[i]) {
                    triplet.push_back(nums[i]);
                    triplet.push_back(nums[left]);
                    triplet.push_back(nums[right]);
                    result.push_back(triplet);
                    triplet.clear();

                    left++, right--;

                    // 第二个数去重
                    while (nums[left-1] == nums[left]) left++;

                    // 第三个数去重
                    while (nums[right] == nums[right+1]) right--;
                }
                else if (nums[left] + nums[right] < -nums[i]) {
                    left++;
                }
                else {
                    right--;
                }
            }
        }

        return result;  
    }  
};  

---

1. 关于该问题更详细的介绍请参考维基百科3SUM词条 ↩