哈希表-map（对于python来说是字典）

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] ==
9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6 输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6 输出：[0,1]

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = {}
        for i,n in enumerate(nums):
            res = target - n
            if res in d:
                return[d[res],i]
            # d存每个数字的下标
            else:
                d[n] = i

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

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

作者：wu_yan_zu
链接：https://leetcode-cn.com/problems/3sum/solution/pai-xu-shuang-zhi-zhen-zhu-xing-jie-shi-python3-by/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

示例 1：

输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]]
示例 2：

输入：nums = [] 输出：[]
示例 3：

输入：nums = [0] 输出：[]

class Solution:
    def threeSum(self, nums):
        ans = []
        n = len(nums)
        nums.sort()
        for i in range(n):
            left = i + 1
            right = n - 1

            # 以为已经排序过了 如果某元素大于0 则之后的和不可能为0
            if nums[i] > 0:
                break

            '''
            错误的去重 nums[i] == nums[i+1] 会漏掉 -1 -1 2这种
            '''
            # 去重 去掉重复的数字 比如 -4 -1 -1 -1  2 需要去掉重复的第一个数字的-1
            # 因为nums[i]是第一个数 之后的i不能与之前的i-1数相同 否则会重复计算相同的数组
            if i >= 1 and nums[i] == nums[i - 1]:
                continue
            while left < right:
                total = nums[i] + nums[left] + nums[right]
                # 说明右边的数大了
                if total > 0:
                    right -= 1
                # 说明左边的数大了
                elif total < 0:
                    left += 1
                else:
                    ans.append([nums[i], nums[left], nums[right]])
                    # 去重逻辑 应该放在找到一个三元组之后 去重是去 与中间数或最后一个数重复的数
                    while (left < right and nums[right] == nums[right - 1]): right -= 1
                    while (left < right and nums[left] == nums[left + 1]): left += 1

                    # 找到答案后 双指针同时收缩
                    right -= 1
                    left += 1
        return ans

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2] 输出：2
解释： 两个元组如下：

1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
   示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0] 输出：1

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :type nums3: List[int]
        :type nums4: List[int]
        :rtype: int
        """

        res = {}
        for n1 in nums1:
            for n2 in nums2:
                key = n1+n2
                if key not in res:
                    res[key]=1
                else:
                    res[key]+=1
        # 如果res中存在 -（n3+n4）=n1+n2
        count = 0
        for n3 in nums3:
            for n4 in nums4:
                key = -n3-n4
                if key in res:
                    count+=res[key] 
        return count            

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：

输入：nums = [2,2,2,2,2], target = 8 输出：[[2,2,2,2]]

思路：
四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是$O(n^2)$，四数之和的时间复杂度是$O(n^3)$ 。

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        nums.sort()
        n =len(nums)
        # if n < 4:
        #     return []
        res = []
        for i in range(n):
            if i>0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1,n):
                if j>i+1 and nums[j] == nums[j-1]:
                    continue
                left = j+1
                right = n-1
                while left<right:
                    total=nums[i]+nums[j]+nums[left]+nums[right]
                    if total >target:
                        right -=1
                    elif total <target:
                        left += 1
                    else:
                        res.append([nums[i],nums[j],nums[left],nums[right]])
                        while left < right and nums[right] == nums[right-1]:right -= 1
                        while left < right and nums[left] == nums[left+1]:left += 1
                        left += 1
                        right -= 1
        return res