【JAVA、C++】LeetCode 018 4Sum

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.

解题思路一：

四路夹逼，C++：

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

解题思路二：

分治，存储所有2个元素的和，然后采用第一题2sum的思路求解即可，这样时间复杂度不过O(n^2)

JAVA实现如下：

	static public List<List<Integer>> fourSum(int[] num, int target) {
		Set<List<Integer>> set = new LinkedHashSet<List<Integer>>();
		HashMap<Integer, List<Integer[]>> hm = new HashMap<Integer, List<Integer[]>>();
		Arrays.sort(num);
		
		for (int i = 0; i < num.length - 1; i++)
			for (int j = i + 1; j < num.length; j++) {
				int sum = num[i] + num[j];
				Integer[] tuple = { num[i], i, num[j], j };
				if (!hm.containsKey(sum))
					hm.put(sum, new ArrayList<Integer[]>());
				hm.get(sum).add(tuple);
			}
		HashSet<Integer> keys= new HashSet<Integer>(hm.keySet());
		for (int key : keys) {
			if (hm.containsKey(key)) {
				if (hm.containsKey(target - key)) {
					List<Integer[]> pairs1 = hm.get(key),pairs2 = hm.get(target - key);
					for (int i = 0; i < pairs1.size(); ++i) {
						Integer[] first = pairs1.get(i);
						for (int j = 0; j < pairs2.size(); ++j) {
							Integer[] second = pairs2.get(j);
							if (first[1] != second[1] && first[1] != second[3]
									&& first[3] != second[1]
									&& first[3] != second[3]) {
								List<Integer> tempList = Arrays.asList(first[0],
										first[2], second[0], second[2]);
								Collections.sort(tempList);
								set.add(tempList);
							}
						}
					}
					hm.remove(key);
					hm.remove(target - key);
				}
			}
		}
		return new ArrayList<List<Integer>>(set);
	}

 C++（TLE）：

#include<string>
#include<vector>
#include<set>
#include<iterator>
#include <stdlib.h>
#include<unordered_map>
#include<algorithm>
using namespace std;
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        set<vector<int>> res;
        vector<vector<int>> result;
        if (nums.size() < 4)
            return result;
        sort(nums.begin(), nums.end());
        unordered_map<int, vector<vector<int>>> hm ;
        for (int i = 0; i < nums.size() - 1; i++) {
            for (int j = i + 1; j < nums.size(); j++) {
                int sum = nums[i] + nums[j];
                vector<int> tuple = { nums[i], i, nums[j], j };
                unordered_map<int, vector<vector<int>>>::iterator iter;
                iter = hm.find(sum);
                if (iter == hm.end()) {
                    vector<vector<int>> tempv;
                    hm.insert(unordered_map<int, vector<vector<int>>>::value_type(sum, tempv));
                }
                hm[sum].push_back(tuple);
            }
        }
        set<int> keys;
        unordered_map<int, vector<vector<int>>>::iterator iter;
        for (iter = hm.begin(); iter != hm.end(); iter++) {
            keys.insert(iter->first);
        }
        for (int key : keys) {
            unordered_map<int, vector<vector<int>>>::iterator iter;
            iter = hm.find(key);
            if (iter != hm.end()){
                unordered_map<int, vector<vector<int>>>::iterator iter;
                iter = hm.find(target - key);
                if (iter != hm.end()){
                    vector<vector<int>> pairs1 = hm[key], pairs2 = hm[target - key];
                    for (int i = 0; i < pairs1.size(); ++i) {
                        vector<int> first = pairs1[i];
                        for (int j = 0; j < pairs2.size(); ++j) {
                            vector<int> second = pairs2[j];
                            if (first[1] != second[1] && first[1] != second[3]
                                && first[3] != second[1]
                                && first[3] != second[3]) {
                                vector<int> tempList = { first[0],first[2], second[0], second[2] };
                                sort(tempList.begin(), tempList.end());
                                res.insert(tempList);
                            }
                        }
                    }
                    hm.erase(key);
                    hm.erase(target - key);
                }
            }
        }
        copy(res.begin(), res.end(), back_inserter(result));
        return result;
    }
};