[LeetCode][JavaScript]4Sum

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.

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)

https://leetcode.com/problems/4sum/

 

 

---

 

 

我看Tags里有HashTable，想想三重循环根本用不到，就没有用这个解法。

先两两合并，再用双指针去找结果，写了好多好伤心。 

1.合并的结果记入twoSumArr，为了查找再开一个twoSumMap记录下数字的组合。

 以题目中的例子来说，twoSumArr -> [-3, -2, -1, 0, 1, 2, 3] ， twoSumMap[0] -> [ [-2, 2], [-1, 1], [0, 0] ]

2.在遍历nums的时候，记下每个数字出现的频率，之后的检查要用到，比如这个结果是不合法的[-2, 1, 0 ,1]，1只能用一次。

3.最后用双指针遍历twoSumArr求结果，这时会碰到重复的情况。

比如 -1 + 1 = 0， twoSumMap[-1] -> [ [-2, 1], [-1, 0] ]，  twoSumMap[1] -> [ [-1, 2], [0, 1] ]

在遍历中加一个判断，前一个(-1)里较大的那个数，小于后一个(1)里较小的数，才要记录到结果中，这样就可以去重。

还是写个三重循环比较简单粗暴，这个要考虑好多种情况。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
var fourSum = function(nums, target) {
    nums = nums.sort(sorting);
    var result = [];
    var countAppear = {}; twoSumMap = {}, twoSumArr = [];
    var i, j, twoSum;
    for(i = 0; i < nums.length; i++){
        if(!countAppear[nums[i]]){
            countAppear[nums[i]] = 1;
        }else{
            countAppear[nums[i]]++;
        }
        for(j = i + 1; j < nums.length; j++){
            twoSum = nums[i] + nums[j]; 
            if(!twoSumMap[twoSum]){
                twoSumArr.push(twoSum);
                twoSumMap[twoSum] = [[nums[i], nums[j]]];
            }else if(!arrContains(twoSumMap[twoSum], nums[i], nums[j])){
                twoSumMap[twoSum].push([nums[i], nums[j]]);
            }
        }
    }
    twoSumArr = twoSumArr.sort(sorting);
    
    var numA, numB, sum4;
    for(i = 0, j = twoSumArr.length - 1; i <= j;){
        numA = twoSumMap[twoSumArr[i]], numB = twoSumMap[twoSumArr[j]];
        sum4 = twoSumArr[i] + twoSumArr[j];
        if(sum4 === target){
            addCandidate(numA, numB, result);
        }
        if(sum4 < target){
            i++;
        }else{
            j--;
        }
    }
    return result;
    
    function verifyResult(arr){
        var previous = null, count = 0;
        for(var i = 0; i < arr.length; i++){
            if(arr[i] !== previous){
                previous = arr[i];
                count = 1;
            }else{
                count++;
                if(count > countAppear[previous]){
                    return false;
                }
            }
        }
        return true;
    }
    function addCandidate(numA, numB, result){
        var i, j, tmp;
        for(i = 0; i < numA.length; i++){
            for(j = 0; j < numB.length; j++){
                if(numA[i][1] <= numB[j][0]){
                    tmp = [numA[i][0], numA[i][1], numB[j][0], numB[j][1]];
                    if(verifyResult(tmp)){
                        result.push(tmp);
                    }   
                }        
            }
        }
    }
    function arrContains(arr, small, large){
        for(var i = 0; i < arr.length; i++){
            if(arr[i][0] === small && arr[i][1] === large){
                return true;
            }
        }
        return false;
    }
    function sorting(a, b){
        if(a > b){
            return 1;
        }else if(a < b){
            return -1;
        }else{
            return 0;
        }
    }
};