3 sum

3-sum 

  题目描述：

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.

题目要求：

• 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.

每个三元组内的元素是按非递减的顺序存放的，并且结果中要求不含有相同的集合。

解法：首先是排序，接着要求是不含有相同的集合，显然可以使用set，但是下面的代码全部都避免使用set。

下面一共使用了3种方法：

法一：DFS，复杂度高，并且在很小的例子上都超时。

class Solution {
private:
    void helper(const vector
   
   
    
     &A, int cur_index, const int max_index, int cur_sum , vector
    
    
     
      &cur_set, set
     
     
      
      
       
        > & ret)
    {
        if(cur_sum > 0 ) return;
        if(cur_index > max_index)
        {
            if(cur_set.size() == 3 && cur_sum == 0 )
            {
                ret.insert(cur_set);
            }
            return;
        }
        cur_set.push_back(A[cur_index]);
        helper(A,cur_index+1, max_index, cur_sum+A[cur_index],cur_set,ret);
        cur_set.pop_back();
        helper(A,cur_index+1,max_index,cur_sum,cur_set,ret);
        return;
    }
public:
    vector
       
        
        
          > threeSum(vector 
         
           &num) { vector 
           
           
             > ret; if(num.empty()) return ret; sort(num.begin(), num.end()); int max_index = num.size()-1; vector 
            
              cur; set 
              
              
                > ret2; helper(num, 0, max_index, 0, cur, ret2); for(auto a:ret2) { ret.push_back(a); } return ret; } }; 
               
              
             
            
           
          
         
       
      
      
     
     
    
    
   
   

法二：枚举所有的2-sum和。再在数组中查找是否存在另外一个数，使得该3个数的和为0.

此法不需要使用set，直接就可以得到结果，但是要注意避免重复计算，如下两点。

注1：上述的枚举2-sum时，对于剩下的那个数只需要在 “下标都大于前两者时”进行。如下例：

在上图中，当枚举到i和j时，另外一个元素只需要在  图示的 k  范围内枚举即可。

注2：如果数组中有大量的重复元素，那么i和j（保持有A[i] == A[j]）就只需要考虑一次即可。

如下例：

上图中，i 和 j只需要考虑一次， 当 j 移动到 j‘ 的时候，是不需要考虑的，因为与前面的 i 和 j  是重复的。

代码如下:

class Solution {
private:
//二分查找另一个数字
int findAnother(const vector
    
    
     
      &A, int left, int right, int target)
{
    if(A.empty()) return -1;
    //int left=0,right=A.size()-1;
    while(left <= right)
    {
        int mid=left+(right-left)/2;
        if(A[mid] == target) return mid;
        if(A[mid] < target) left = mid+1;
        else right=mid-1;
    }
    return -1;
}
public:
    vector
     
     
      
      
       
        > threeSum(vector
       
       
        
         &num)
    {
        vector
        
         
         
           > ret; if(num.empty()) return ret; int n = num.size(); vector 
          
            temp(3,0); sort(num.begin(), num.end()); //首先排序 for(int i=0;i 
           
             0 && num[i]==num[i-1]) //避免重复计算，导致输出集合中的重复的元素 continue; if(num[i] > 0) break; //由于数组值有序的，当前的num[i]如果大于0，可直接break，因为后面的不可能满足了 for(int j=i+1;j 
            
              i+1 && num[j]==num[j-1]) //避免重复计算，导致输出集合中的重复的元素 continue; int sum2 = num[i]+num[j]; if(sum2 > 0) break; //由于数组值有序的，当前的和如果大于0，可直接break int index = findAnother(num,j+1,n-1,0-sum2); if(index != -1) { temp[0] = num[i]; temp[1]=num[j]; temp[2]=num[index]; ret.push_back(temp); } } } return ret; } }; 
             
            
           
          
        
       
       
      
      
     
     
    
    

时间复杂度为： n^2(logn)

法三：由于2-sum在数组有序的情况下我们是可以O(n)的时间来解决的，于是直接使用已有的2-sum的代码，代码如下：

class Solution {
public:
    vector
     
     
      
      
       
        > threeSum(vector
       
       
        
         &num)
    {
        vector
        
        
         
         
           > ret; if(num.empty()) return ret; int n = num.size(); vector 
          
            temp(3,0); sort(num.begin(), num.end()); for(int i = 0 ; i < n-2; ++i) { if(i > 0 && num[i] == num[i-1]) continue; int left = i+1, right = n-1; int target = -num[i]; while(left < right) { if(left > i+1 && num[left] == num[left-1]) //避免重复加入 { left++; continue; } if(right < n-1 && num[right] == num[right+1]) //避免重复加入 { right--; continue; } int sum = num[left] + num[right]; if(sum == target) { temp[0] = num[i]; temp[1]=num[left], temp[2]= num[right]; ret.push_back(temp); left++; right--; } else if(sum > target) right--; else left++; } } return ret; } };