【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() < )
             return res;
         sort(num.begin(), num.end());
         for (int i = ; i <= num.size() - ; i++) {
             for (int j = i + ; j <= num.size() - ; j++) {
                 int k = j + , l = num.size() - ;
                 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 - ] && k < l)
                             k++;
                         while (num[l] == num[l + ] && k < l)
                             l--;
                     }
                 }
                 while (j < num.size() -  && num[j] == num[j + ])
                     j++;
             }
             while (i < num.size()- && num[i] == num[i + ])
                 ++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() < )
             return result;
         sort(nums.begin(), nums.end());
         unordered_map<int, vector<vector<int>>> hm ;
         for (int i = ; i < nums.size() - ; i++) {
             for (int j = i + ; 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 = ; i < pairs1.size(); ++i) {
                         vector<int> first = pairs1[i];
                         for (int j = ; j < pairs2.size(); ++j) {
                             vector<int> second = pairs2[j];
                             if (first[] != second[] && first[] != second[]
                                 && first[] != second[]
                                 && first[] != second[]) {
                                 vector<int> tempList = { first[],first[], second[], second[] };
                                 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;
     }
 };