leetcode 4Sum Summary for unique and duplicates

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

Note:

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

    For example, given array S = {1 0 -1 0 -2 2}, and target = 0.

    A solution set is:
    (-1,  0, 0, 1)
    (-2, -1, 1, 2)
    (-2,  0, 0, 2)

We should pay attention to the duplicates in this problem. STL offers a way to be unique: 

class Solution {
public:
	vector<vector<int> > fourSum(vector<int> &num, int target) {
		vector<vector<int> > ret;
		if(num.size() < 4) return ret;
		sort(num.begin(), num.end());
		for(int i = 0; i < num.size(); ++i)
			for(int j = i + 1; j < num.size(); ++j) {
				int left = j + 1;
				int right = (int)num.size() - 1;
				int sum = 0;
				while(left < right){
					sum=num[i]+num[j]+num[left]+num[right];
					if(target == sum){
						ret.push_back(vector<int>(4));
						ret.back()[0]=num[i];
						ret.back()[1]=num[j];
						ret.back()[2]=num[left];
						ret.back()[3]=num[right];
						++left;
						--right;
					}
					else if(sum > target)
						--right;
					else
						++left;
				}
			}
		vector<vector<int>>:: iterator it = unique(ret.begin(),ret.end());
		ret.resize(distance(ret.begin(), it)); 
		return ret;
	}
};

The function unique  Removes all but the first element from every consecutive group of equivalent elements in the range [first,last) . Here's the example from the cplusplus.com. Vectors could be sorted since we could compare every two vectors. 

// unique algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::unique, std::distance
#include <vector>       // std::vector

bool myfunction (int i, int j) {
  return (i==j);
}

int main () {
  int myints[] = {10,20,20,20,30,30,20,20,10};           // 10 20 20 20 30 30 20 20 10
  std::vector<int> myvector (myints,myints+9);

  // using default comparison:
  std::vector<int>::iterator it;
  it = std::unique (myvector.begin(), myvector.end());   // 10 20 30 20 10 ?  ?  ?  ?
                                                         //                ^

  myvector.resize( std::distance(myvector.begin(),it) ); // 10 20 30 20 10

  // using predicate comparison:
  std::unique (myvector.begin(), myvector.end(), myfunction);   // (no changes)

  // print out content:
  std::cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

Another way to avoid duplicates is using set, int num; string tmp += num; So num could be treated as a character. However, when num > 255, it could be seen as num%256. So,

#include<vector>
#include<stdio.h>
#include<iostream>
#include<set>
#include<map>
#include<algorithm>
#include<string>//不添加string会出现模版的错误
using namespace std;

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int nSize = num.size();
        vector< vector<int> > result;
        if (nSize < 4) return result;
        
        sort(num.begin(), num.end());
        vector<int> mid(4);//指定对象的大小为4，mid(4,1)含有4个元素，每个为1
		
        set<string> isExit;
        for (int i = 0; i < nSize - 3; ++i)
        {
            mid[0] = num[i];
            for (int j = i + 1; j < nSize - 2; ++j)
            {
                mid[1] = num[j];
                int l = j + 1;
                int r = nSize - 1;
                int sum = target - num[i] - num[j];
                while(l < r)
                {
                    int tmp = num[l] + num[r];
                    if (sum == tmp)
                    {
                        string str;
                        str += num[i];
                        str += num[j];
                        str += num[l];
                        str += num[r];
                        set<string>::iterator itr = isExit.find(str);//利用set标记是否被占用
                        if (itr == isExit.end())
                        {
                            isExit.insert(str);
                            mid[2] = num[l];
                            mid[3] = num[r];
                            result.push_back(mid);
                        }
                        ++l;
                        --r;
                    }
                    else if(sum > tmp)
                        ++l;
                    else
                        --r;
                }
            }
        }

        return result;
    }
};
int main(){
	Solution s;
	int a[4] = {4,5,6,7};
	vector<vector<int> > res;
    vector<int> vec(a, a + 4);
	res=s.fourSum(vec,26);

	return 0;
}

The last way is to use direct comparison. 

class Solution {
public:
	vector<vector<int> > fourSum(vector<int> &num, int target) {
		vector<vector<int> > ret;
		if(num.size() < 4) return ret;
		sort(num.begin(), num.end());
		for(int i = 0; i < num.size(); ++i) {
		    if (i > 0 && num[i] == num[i - 1])
		      continue;
			for(int j = i + 1; j < num.size(); ++j) {
			    if (j > i + 1 && num[j] == num[j - 1])
			      continue;
				int left = j + 1;
				int right = (int)num.size() - 1;
				int sum = 0;
				while(left < right){
				    if (left > j + 1 && num[left] == num[left - 1]) {
				      ++left;
				      continue;
				    }
					sum=num[i]+num[j]+num[left]+num[right];
					if(target == sum){
						ret.push_back(vector<int>(4));
						ret.back()[0]=num[i];
						ret.back()[1]=num[j];
						ret.back()[2]=num[left];
						ret.back()[3]=num[right];
						++left;
						--right;
					}
					else if(sum > target)
						--right;
					else
						++left;
				}
			}
		}
		return ret;
	}
};