LeetCode#18 4 Sum

Problem Definition:

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)

Solution:

1）最直接的思路，固定第一个数，变成 3 Sum 问题，进而变成2 Sum 问题；这个想法可以扩展到k-Sum。重复元组的问题通过跳过重复元素来避免。

    # @param {integer[]} nums
    # @param {integer} target
    # @return {integer[][]}
    def fourSum(nums, target):
        nums.sort()
        res=[]
        first=0
        finalFirst=len(nums)-4
        finalSecond=len(nums)-3
        rightBound=len(nums)-1
        while first<=finalFirst:
            nf=nums[first]
            second=first+1
            while second<=finalSecond:
                left=second+1
                right=rightBound
                ns=nums[second]
                while left<right:
                    nl=nums[left]
                    nr=nums[right]
                    four=nf+ns+nl+nr
                    if four>target:
                        right-=1
                    elif four<target:
                        left+=1
                    else:
                        res+=[nf, ns, nl, nr],
                        while left<right and nums[left]==nl:
                            left+=1
                        while left<right and nums[right]==nr:
                            right-=1
                second+=1
                while second<=finalSecond and nums[second]==ns:
                    second+=1
            first+=1
            while first<=finalFirst and nums[first]==nf:
                first+=1
        return res

2）HashTable. 数组中元素两两求和，以和为key，对应的value是多个四元组组成的数组，每个四元组保存了和为key的两个元素，及他们的下标。O(n^2)时间形成这个表。

     然后遍历HashTable [O(n)]，对key1，找到能够相加得target的key2 [O(1)]，把这俩key对应的value内的四元组交叉组合。防止重复是关键。可以用Set（集合）来存储这些交叉后的元组。

    # @param {integer[]} nums
    # @param {integer} target
    # @return {integer[][]}
    def fourSum(self, nums, target):
        n=len(nums)
        if n<4:
            return []
        vsMap={}     
        res=[]
        for i in range(n):
            for j in range(i+1,n):
                key=nums[i]+nums[j]
                vsMap.setdefault(key, [])
                vsMap[key].append([nums[i], i, nums[j], j])
        for key in vsMap:
            need=target-key
            if need in vsMap:
                pB=vsMap[need]
            else:
                continue
            pA=vsMap[key]
            for a in pA:
                for b in pB:
                    if a[1]==b[1] or a[3]==b[3] or a[1]==b[3] or a[3]==b[1]:
                        continue
                    cmb=sorted([a[0], a[2], b[0], b[2]])
                    if cmb not in res:
                        res+=cmb,     
        return res