3Sum

题目

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)

思路一

类似于

用类似于  Combinations   的方式：

这里用 set<vector<int>> 是为了去除重复，例如 [0,0,0,0,0]  本来结果只有一组，如果用 vector<vector<>int> 则会出现重复的情况。

用set可以去除重复的情况，但是会额外增加时间，大数据未能通过。所以我们需要用另一种去重复的方法来替代 set 才可以。

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        set<vector<int>> result;
        sort(num.begin(),num.end());    
        vector<int> myvec;
        mythree(result,myvec,num,0,0);
        return vector<vector<int>>(result.begin(),result.end());
    }
    
    void mythree(set<vector<int>> &result, vector<int> &vec, vector<int> &num, int cur, int sum)
    {
        if(vec.size()==3)
        {
            if(sum==0)
                result.insert(vec);
            return ;
        }
        if(cur==num.size())
            return ;
        if(vec.size()<3)
        {
            vec.push_back(num[cur]);
            mythree(result,vec,num,cur+1,sum-num[cur]);
            vec.pop_back();
            mythree(result,vec,num,cur+1,sum);
        }       
    }   
    
};

 

排列 Permutation 和 Combination 的不同之处是：

（1）在排列中：

        for(int i=start;i<num.size();i++)      
        {      
            if(i>start && num[i]==num[i-1])    
                continue;                
            vec.push_back(num[i]);                 
            combinationSum(result,num,i+1,vec,target-num[i]);      
            vec.pop_back();    
        }  

（2）在组合中：

        combinationSum(result,num,start+1,vec,target);  
        vec.push_back(num[start]);   
        combinationSum(result,num,start+1,vec,target-num[start]);  
        vec.pop_back();  

思路二

用类似 Permutations  和 Combination Sum II ，同时加入去重复机制，顺利通过小大数据集。

注意：加了判断重复的语句    if(i>start && num[i]==num[i-1])    continue;

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int>> result;
        if(num.size()<3)
            return result;
        sort(num.begin(),num.end());    
        vector<int> myvec;
        mythree(result,myvec,num,0,0);
        return result;
    }
    
    void mythree(vector<vector<int>> &result, vector<int> &vec, vector<int> &num, int cur, int sum)
    {
        if(vec.size()==3)
        {
            if(sum==0)
                result.push_back(vec);
            return ;
        }
        if(vec.size()>3 || cur==num.size())
            return ;     
        for(int i=cur;i<num.size();i++)
        {
            if(i>cur && num[i]==num[i-1])    
                continue; 
            vec.push_back(num[i]);
            mythree(result,vec,num,i+1,sum-num[i]);
            vec.pop_back();
        }       
    }   
    
};

思路三

时间O(N2) 。

i 表示中间的元素，依次遍历；

left 表示最左边的元素，从i-1开始向左遍历；

right 表示最后一个元素，从i+1开始向右遍历；

 

用set<vector<int>> 来去除重复情况。

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        set<vector<int>> result;
        if(num.size()<3)  
            return vector<vector<int>>();  
        sort(num.begin(),num.end());  
        for(int i=1;i<num.size()-1;i++)  
        {  
            int left = i-1;  
            int right = i+1;  
            while(left>=0 && right<num.size())  
            {  
                int tmp = num[left]+num[i]+num[right];  
                if(tmp==0)  
                {
                    vector<int> vec;
                    vec.push_back(num[left]);
                    vec.push_back(num[i]);
                    vec.push_back(num[right]);
                    result.insert(vec);
                    right++;
                    left--;
                }
                else if(tmp<0)                 
                    right++;  
                else 
                    left--;  
            }  
        }  
        return vector<vector<int>>(result.begin(),result.end());
    }  
};  

如果要人工的去除重复，而不是用 set 数据结构，用上述思想就不容易了。

因为 [ -1,0 ,0,0,0,1 ] ，会出现很多重复的情况。正确的结果是：先选取中间元素0，得到 [-1,0,1] ，再选取 0 ，得到[0,0,0] ；但是上述方法会有右边的[-1,0,1] 重复。

若接下来若遇到相同的 num[i]=num[i-1]，就continue，就会遗漏 [0,0,0] 。

所以我们更换思想，让重复判断更容易一些：

i 表示最左边的元素，依次遍历；

left 表示中间元素，从i+1开始遍历；

right 表示最后一个元素，从n-1开始遍历；

若遇到重复的 left 或 right ，就增加。

若遇到重复的 i ，就跳过。

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int>> result;
        if(num.size()<3)  
            return vector<vector<int>>();  
        bool used = false;
        sort(num.begin(),num.end());  
        for(int i=0;i<num.size()-2;i++)  
        {  
            int left = i+1;  
            int right = num.size()-1;  
            while(left<right)  
            {  
                int tmp = num[i]+num[left]+num[right];  
                if(tmp==0)
                {                        
                    vector<int> vec;
                    vec.push_back(num[i]);
                    vec.push_back(num[left]);
                    vec.push_back(num[right]);
                    result.push_back(vec);
                    right--;                    
                    left++;
                    while(left<right && num[left]==num[left-1])    left++;
                    while(left<right && num[right]==num[right+1])  right--;                  
                }
                else if(tmp<0)   
                     {
                        left++;
                        while(left<right && num[left]==num[left-1])  left++;  
                     }
                else 
                {
                    right--;  
                    while(left<right && num[right]==num[right+1])  right--;
                }
            } 
            while(num[i]==num[i+1])  i++;
        }  
        return result;
    }  
};  

 

上述代码进一步简化：

注意判断 left!=i+1  和  right!=num.size()-1

class Solution {  
public:  
    vector<vector<int> > threeSum(vector<int> &num) {  
        // Start typing your C/C++ solution below   
        // DO NOT write int main() function   
        vector<vector<int>> result;  
        if(num.size()<3)    
            return vector<vector<int>>();    
        bool used = false;  
        sort(num.begin(),num.end());    
        for(int i=0;i<num.size()-2;i++)    
        {    
            int left = i+1;    
            int right = num.size()-1;    
            while(left<right)    
            {    
                int tmp = num[i]+num[left]+num[right];  
                if(left!=i+1 && num[left]==num[left-1]){
                    left++;
                }else if(right!=num.size()-1 && num[right]==num[right+1]){
                    right--;
                }else if(tmp<0){
                    left++;
                }else if(tmp>0){
                    right--;
                }else{                     
                    vector<int> vec;  
                    vec.push_back(num[i]);  
                    vec.push_back(num[left]);  
                    vec.push_back(num[right]);  
                    result.push_back(vec);  
                    right--;                      
                    left++;                   
                }   
            }   
            while(num[i]==num[i+1])  i++;  
        }    
        return result;  
    }    
};