leetcode18

先给出一个使用回溯法，求“组合”，但是这种方案会TLE：

class Solution:
    def __init__(self):
        self.filter = set()
        self.result = []

    def trackBack(self,nums,i,temp,target):
        if len(temp) == 4:
            cursum = nums[temp[0]] + nums[temp[1]] + nums[temp[2]] + nums[temp[3]]
            if cursum == target:
                k = (nums[temp[0]] , nums[temp[1]] , nums[temp[2]] , nums[temp[3]])
                if k not in self.filter:
                    self.filter.add(k)
                    self.result.append([nums[temp[0]] , nums[temp[1]] , nums[temp[2]] , nums[temp[3]]])
            return
        for j in range(i,len(nums)):
            if j not in temp:
                temp.append(j)
                self.trackBack(nums,j,temp,target)
                temp.pop(-1)
        
    def fourSum(self, nums: 'List[int]', target: int) -> 'List[List[int]]':
        nums = sorted(nums)
        temp = []
        self.trackBack(nums,0,temp,target)
        return self.result

下面给出一个AC的参考的答案，

参考地址：https://leetcode.com/problems/4sum/discuss/8545/Python-140ms-beats-100-and-works-for-N-sum-(Ngreater2)

class Solution:
    def fourSum(self, nums, target):
        nums.sort()
        results = []
        self.findNsum(nums, target, 4, [], results)
        return results

    def findNsum(self, nums, target, N, result, results):
        if len(nums) < N or N < 2: return

        # solve 2-sum
        if N == 2:
            l,r = 0,len(nums)-1
            while l < r:
                if nums[l] + nums[r] == target:
                    results.append(result + [nums[l], nums[r]])
                    l += 1
                    r -= 1
                    while l < r and nums[l] == nums[l - 1]:
                        l += 1
                    while r > l and nums[r] == nums[r + 1]:
                        r -= 1
                elif nums[l] + nums[r] < target:
                    l += 1
                else:
                    r -= 1
        else:
            for i in range(0, len(nums)-N+1):   # careful about range
                if target < nums[i]*N or target > nums[-1]*N:  # take advantages of sorted list
                    break
                if i == 0 or i > 0 and nums[i-1] != nums[i]:  # recursively reduce N
                    self.findNsum(nums[i+1:], target-nums[i], N-1, result+[nums[i]], results)
        return

这题相当于是在两个数的基础上增加两层循环，或是在三个数的基础上增加一层循环，对之前的“基础前置”题目记不住，这道题就很难写出来。

这道题目难度属于Medium，是对于已经掌握了之前的两道题目的人来划分的。

如果做题的人没有之前的基础，没有做过之前那两道题，那就是hard级别了。