LeetCode: 4 Sum

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)

#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
using namespace::std;
class Solution {
public:
	long RSHash(string str)
	{
		int a = 876283;
		int b = 21382;
		long hash = 0;
		for(int i = 0; i < str.size(); i++)
		{
			hash = a * hash + str[i];
			a = a * b;
		}
		return hash;
	}
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
		int i = 0, j = i + 1, l = num.size() - 1;
		string str;
		int key = 0;
		vector< vector<int> > result;
		vector<int> set;
		map<long, int> mymap;
		if(num.size() < 4)
		{
			return result;
		}
		sort(num.begin(), num.end());
		for(int x = 0; x < num.size() - 3; x++){
			int a = num[x];
		for(i = x + 1; i < num.size() - 2; i++)
		{
			int b = num[i];
			for(j = i + 1, l = num.size() - 1; j < l; )
			{
				int c = num[j];
				int d = num[l];
				if(a + b + c + d < target)
				{
					j++;
				}
				else if(a + b + c + d > target)
				{
					l--;
				}
				else
				{
					str.clear();
					str += a;
					str += b;
					str += c;
					str += d;
					key = RSHash(str);
					if(mymap.find(key) == mymap.end())
					{
						mymap[key] = 1;
						set.push_back(a);
						set.push_back(b);
						set.push_back(c);
						set.push_back(d);
						result.push_back(set);
						set.clear();
					}
					j++;
				}
			}
		}
		}
		return result;
        
    }
};

int main()
{
	vector<int> aa;
	
	aa.push_back(-1);
	aa.push_back(0);
	aa.push_back(1);
	aa.push_back(2);
	
	aa.push_back(-1);
	
	aa.push_back(-4);
	
	Solution ss;
	ss.fourSum(aa,4);
//	ss.print(ss.threeSum(aa));
}

Round 2:

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
    
        vector<vector<int> > result;
        if(num.size() < 4)
            return result;
        std::sort(num.begin(), num.end());
        for(int i = 0; i < num.size()-3; i++)
        {
            for(int j = i+1; j < num.size()-2; j++)
            {
                int l = j+1, r = num.size()-1;
                while(l < r)
                {
                    if(num[i] + num[j] + num[l] + num[r] == target)
                    {
                        vector<int> cur;
                        cur.push_back(num[i]);
                        cur.push_back(num[j]);
                        cur.push_back(num[l]);
                        cur.push_back(num[r]);
                        result.push_back(cur);
                        while(l+1 < r && num[l] == num[l+1])
                            l++;
                        while(r-1 > l && num[r] == num[r-1])
                            r--;
                        l++;
                        r--;
                    }
                    else if(num[i] + num[j] + num[l] + num[r] < target)
                    {
                        l++;
                    }
                    else
                        r--;
                }
                while(j+1 < num.size()-2 && num[j] == num[j+1])
                    j++;
            }
            while(i+1 < num.size()-3 && num[i] == num[i+1])
                i++;
        }
        return result;
    }
};