leetcode-数组之和类题目

1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
限制条件：

1. 两数之和（后面有三数之和、四数之和的题目，还可以拓展为任意个数之和）
2. 只有一个满足条件的输出（拓展为输出所有满足条件的结果）
3. 数组中有重复元素，但是同一元素不能重复利用
4. 要求输出等于目标值的元素下标（可以扩展为最接近目标值的元素下标等）

（1）暴力两层循环

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)-1):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i, j]

时间复杂度$O(N^2)$, 附加空间复杂度$O(1)$, 运行时间6208ms, 内存消耗13.7MB.

（2）两次哈希

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = dict()
        for i, item in enumerate(nums):
            d[item] = i
        for i in range(len(nums)):
            tmp = target - nums[i]
            if tmp in d and d[tmp] != i:
                return [i, d[tmp]]

时间复杂度$O(N)$, 附加空间复杂度$O(N)$, 运行时间48ms, 内存消耗14.9MB.

（3） 一次哈希

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = dict()
        for i, item in enumerate(nums):
            tmp = target - item
            if tmp in d:
                return [i, d[tmp]]
            d[item] = i

时间复杂度$O(N)$, 附加空间复杂度$O(N)$, 运行时间84ms, 内存消耗14.2MB.

167.两数之和II

给定一个按照升序排列的有序数组，找到两个数使得他们相加之和等于目标值，返回它们的下标。
注意：你可以假设只有一个正确答案，而且数组下标从1开始。
输入：nums=[2, 7, 11, 15], target=9
输出：[1, 2]

（1）一次哈希

思路：采用和第一题相同的思路，时间复杂度$O(N)$, 附加空间复杂度$O(N)$

（2）双指针

思路：双指针分别指向首尾元素，根据当前元素之和与目标值的大小关系移动指针

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        i, j = 0, len(numbers)-1
        while i < j:
            s = numbers[i] + numbers[j]
            if s == target:
                return [i+1, j+1]
            elif s < target:
                i += 1
                while i < j and numbers[i] == numbers[i-1]:
                    i += 1
            else:
                j -= 1
                while i < j and numbers[j] == numbers[j+1]:
                    j -= 1

时间复杂度$O(N)$, 附加空间复杂度$O(1)$

15.三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组
输入：[-1, 0, 1, 2, -1, -4]，输出：[ [-1, 0, 1], [-1, -1, 2]]

（1） 暴力三层循环

时间复杂度$O(n^3)$，空间复杂度$O(n)$

（2） 排序+一层循环（双指针）

思路：首先将数组从小到大排序。然后固定第一个数（依次遍历），定义两个指针指向第一个数后面元素的首尾元素，根据当前三数之和与目标值的关系移动指针。注意过滤掉不可能的情况和重复的情况。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        for i in range(len(nums)-2):
            if nums[i]>0:
                break
            if i > 0 and nums[i] == nums[i-1]:
                continue
            left, right = i+1, len(nums)-1
            while left < right:
                sum = nums[i]+nums[left]+nums[right]
                if sum == 0:
                    res.append(sorted([nums[i], nums[left], nums[right]]))
                    left+=1
                    while left+1<right and nums[left] == nums[left-1]:
                        left+=1
                    right-=1
                    while right-1>left and nums[right] == nums[right+1]:
                        right-=1
                elif sum > 0:
                    right-=1
                    while right-1>left and nums[right] == nums[right+1]:
                        right-=1
                else:
                    left+=1
                    while left+1 < right and nums[left] == nums[left-1]:
                        left+=1
        return res

时间复杂度$O(n^2)$，空间复杂度$O(n)$

16.最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
输入：数组 nums = [-1，2，1，-4], target = 1.
输出：与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
思路：和三数之和类似，首先排序，然后固定第一个数，双指针指向后面元素的首尾，判断与目标值的关系，移动指针。不同的是这里需要维护一个变量保存与目标值的最小绝对差值以及对应的三元组。同样需要过滤掉不可能的情况和重复的情况。

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        diff = 2147483647
        res = target
        for i in range(len(nums)-2):
            left = i+1
            right = len(nums)-1
            while left < right:
                s = nums[i] + nums[left] + nums[right]
                if s == target:
                    return s
                elif s < target:
                    if target - s < diff:
                        diff = target-s
                        res = s
                    left += 1
                    while left + 1 < right and nums[left] == nums[left-1]:
                        left+=1
                else:
                    if s - target < diff:
                        diff = s - target
                        res = s
                    right -= 1
                    while right-1>left and nums[right] == nums[right+1]:
                        right-=1
        return res

时间复杂度$O(n^2)$，空间复杂度$O(n)$

18.四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
思路：与三数之和类似，只不过这里需要进行两次遍历，考虑更多的不可能情况和重复情况。

class Solution:
    def fourSum(self, nums, target):
        nums.sort()
        res = []
        for i in range(len(nums)-3):
            if nums[i] > target:
                break
            for j in range(i+1, len(nums)-2):
                if nums[i]+nums[j] > target:
                    break
                left = j+1
                right = len(nums)-1
                while left < right:
                    s = nums[i]+nums[j]+nums[left]+nums[right]
                    if s == target:
                        res.append(sorted([nums[i], nums[j], nums[left], nums[right]]))
                        left += 1
                        while left+1 < right and nums[left] == nums[left-1]:
                            left+=1
                        right -= 1
                        while right-1>left and nums[right] == nums[right+1]:
                            right-=1
                    elif s < target:
                        left+=1
                        while left+1 < right and nums[left] == nums[left-1]:
                            left+=1
                    else:
                        right -= 1
                        while right-1>left and nums[right] == nums[right+1]:
                            right-=1
        return res

时间复杂度$O(n^3)$，空间复杂度$O(n)$

扩展题目

1. 输入数组nums和目标值target，从数组中选取两个元素使其和等于目标值，输出所有满足条件的元素下标。
2. 输入数组nums和目标值target，从数组中选取一至多个元素使其和等于目标值，输出所有满足条件的元素下标（数组元素可以重复使用&数组元素不可以重复使用）

input: nums = [1, 2, 3, 5, 8], target = 8
output: 
[[8], [1, 2, 5], [2, 2, 2, 2], [1, 2, 2, 3], [3, 5]]