leetcode第15题--3Sum

Problem:

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)

先说说我的思路吧。先排序。我也不知道为什么莫名其妙的想到固定中间一个数的方法。i从第二个开始一直到倒数第二个数，然后left从i的左边一个开始，right从i的右边一个开始，如果三个数相加大于零，那么肯定就要left往左，如果相加小于零那就right往右，如果等于零，再判断是否与已经存入sum中的最后一个判断比较不相等就写入。现在就碰到了以前没有碰到过的问题，不是Time Limit Exceeded，而是Output Limit Exceeded。查了下说，这个问题应该是while循环没有出来。但是我看了以下代码，没有理由没跳出来啊。

class Solution {
public:
vector<vector<int> > threeSum(vector<int> &num)
{
    bool flag = false;
    vector<vector<int> > sum;
    vector<int> temp = num;
    sort(temp.begin(), temp.end());
    if (num.size() < 3 || temp[0] > 0)
    return sum;
    
    for (int i = 1; i != num.size() - 1; i++)
    {
        int left = i - 1, right = i + 1;
        while(left>=0 && right < num.size())
        {
            if (temp[left] + temp[i] + temp[right] == 0)
            {
                vector<int> sub;
                sub.push_back(temp[left]);
                sub.push_back(temp[i]);
                sub.push_back(temp[right]);
                if (!flag)
                {
                    flag = true;
                    sum.push_back(sub);
                }
                else if(sub != sum[sum.size()-1])
                {
                    sum.push_back(sub);
                }
                left--;
                right++;
            }
            else if(temp[left] + temp[i] + temp[right] < 0)
            {
                right++;
            }
            else
                left--;
        }
    }
    sum.erase(unique(sum.begin(), sum.end()), sum.end());
    return sum;
}
};

后来请实验室的大牛（可能要去Google工作了）看了下。说应该是内存不够了。就是还是存了相同的例子。单单用判断是不是等于sum的最后一个是否相等是不行的。应该是这样，OJ里测试的时候估计给了sum的大小有限。如果重复了那就Output Limit了。其实我差成功只是一小步了。

以下代码是固定三个数的第一个，然后i从第一个到倒数第三个就行了。如果i往前移动的时候和前一个数相等那就不用再判断了，直接i++，因为以该数开头的三元组都已经计算过并存起来了。其中还有一个很好的地方就是在判断三元组是不是第一个的时候，用的是sum.size()==0 || sum.size() > 0 ...这个很好，因为第一次的时候是==0的，那||之后的就不作判断了。下一次的时候size不==0.再做后面的判断，后面的判断是因为三个数只要有两个数相等那第三个肯定也相等。代码如下。

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        vector<vector<int> > sum;
        if(num.size()<3)
            return sum;
        sort(num.begin(),num.end());
        int k = 0;
        for(int i = 0;i<num.size()-2;i++)
        {
            if(i>0 && num[i] == num[i-1])
                continue;
            int j = i+1;
 
            if(num[i]+num[j]>0)
                break;
            k = num.size()-1;
            while(j<k)
            {
            if(num[i]+num[j]+num[k] == 0)
            {
                if(sum.size()==0 || sum.size()>0 && !(num[i]==sum[sum.size()-1][0]&& num[j] ==sum[sum.size()-1][1] ))
                {
                vector<int> ansPiece;
                ansPiece.push_back(num[i]);
                ansPiece.push_back(num[j]);
                ansPiece.push_back(num[k]);
                sum.push_back(ansPiece);
                }
            }
            if(num[i]+num[j]+num[k] < 0)
                j++;
            else
                k--;
            }
        }
        return sum;
    }
};

2015/4/3:

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        sort(num.begin(), num.end());
        vector<vector<int> > ans;
        for (int i = 0; i < num.size(); i++){
            int target = -1 * num[i];
            if (i > 0 && num[i] == num[i-1])
                continue;
            int left = i + 1, right = num.size() - 1;
            while (left < right){
                if (target == num[left] + num[right]){
                    vector<int> tmp;
                    tmp.push_back(num[i]);
                    tmp.push_back(num[left]);
                    tmp.push_back(num[right]);
                    ans.push_back(tmp);
                    while(left < num.size() && num[left] == tmp[1])
                        left++;
                    while(right > 0 && num[right] == tmp[2])
                        right--;
                }
                else if (target > num[left] + num[right])
                    left++;
                else
                    right--;
            }
            
        }
        return ans;
    }
};