【LeetCode】四数之和——18_4Sum

今天开始正式进行LeetCode的刷题之旅，自己的编程算法能力都太差了，所以决定进行苦练，查到的代码和解法，优化以及个人的理解，就这样。

专栏——【LeetCode】

LeetCode题目分类总结

在这里插入图片描述

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：答案中不可以包含重复的四元组。

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

满足要求的四元组集合为：
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

题解1：

暴力拆解法真的是非常的简洁！！！但是正如大家所知，这种做法的时间复杂度是O(n^4)。。。基本上都是超出时间限制。

class Solution:
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        result = []
        for i, a in enumerate(nums):
            for j, b in enumerate(nums[i + 1:]):
                for k, c in enumerate(nums[j + i + 2:]):
                    for _, d in enumerate(nums[i + j + k + 3:]):
                        if a + b + c + d == 0:
                            result.append([a, b, c, d])
        return result

题解2：

如何提高速度呢？我们可以将c+d的每一种结果添加到查找表中，这样我们只需要遍历a\b两个数组，之后在查找表中查找0 - a - b就可以解决问题。

需要先建立一个map存储nums中所有不同的两个数和，然后记录它在nums中的坐标位置。

class Solution:
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        nums.sort()
        result = list()
        nums_len = len(nums)
        if nums_len < 4:
            return result
        if nums[0] * 4 > target or nums[nums_len - 1] * 4 < target:
            return result
            
        nums_map = {}
        for i in range(nums_len-1, 0, -1):
            if i < nums_len - 1 and nums[i] == nums[i + 1]:
                continue
            for j in range(i-1, -1, -1):
                if j < i-1 and nums[j] == nums[j + 1]:
                    continue
                if nums[i] + nums[j] not in nums_map:
                    nums_map[nums[i] + nums[j]] = [[j, i]]
                else:
                    nums_map[nums[i] + nums[j]].append([j, i])

        for i in range(nums_len - 3):
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            for j in range(i+1, nums_len - 2):
                if j > i + 1 and nums[j] == nums[j - 1]:
                    continue
                
                dif = target - nums[i] - nums[j]
                if dif not in nums_map:
                    continue
                else:
                    for num in nums_map[dif]:
                        if num[0] > j:
                            result.append([nums[i], nums[j], nums[num[0]], nums[num[1]]])
        return result

题解3：

通过双指针的方式解决问题，把多数求和转化成 2-sum ，但是比较难想到，可以通过培养经验或者后期优化得到。

class Solution(object):
    def fourSum(self, nums, target):
        def findNsum(l, r, target, N, result, results):
            if r - l + 1 < N or N < 2 or target < nums[l] * N or target > nums[r] * N:
                return
                
            # two pointers solve sorted 2-sum problem
            if N == 2:
                while l < r:
                    s = nums[l] + nums[r]
                    if s == target:
                        results.append(result + [nums[l], nums[r]])
                        l += 1
                        while l < r and nums[l] == nums[l - 1]:
                            l += 1
                    elif s < target:
                        l += 1
                    else:
                        r -= 1
            else:
                for i in range(l, r + 1):
                    if i == l or (i > l and nums[i - 1] != nums[i]):
                        findNsum(i + 1, r, target - nums[i], N - 1, result + [nums[i]], results)
        nums.sort()
        results = []
        findNsum(0, len(nums) - 1, target, 4, [], results)
        return results