力扣-两数求和-三数求和问题

1. 两数之和

15. 三数之和

18. 四数之和

167. 两数之和 II - 输入有序数组

560. 和为K的子数组

653. 两数之和 IV - 输入 BST

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 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]

 

解题思路如下：

这道题的重点在于首先找到这2个数，且输出的值不重复。我们就做2个for循环，然后再输出即可

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        lenth = len(nums)
        for i in range(lenth):
            for j in range(i+1,lenth):
                c=nums[i]+nums[j]
                if c==target:
                    return [i,j]

15. 三数之和

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

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

 

示例 1：

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

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

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

思路：这道题其实不难，主要会超时，因此我们需要优化思路，不能做太多for循环，看了一下k神的思路，就很清晰了

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res, k = [], 0
        for k in range(len(nums) - 2):
            if nums[k] > 0: 
                break # 1. because of j > i > k.
            if k > 0 and nums[k] == nums[k - 1]: 
                continue # 2. skip the same `nums[k]`.
            i, j = k + 1, len(nums) - 1
            while i < j: # 3. double pointer
                s = nums[k] + nums[i] + nums[j]
                if s < 0:
                    i += 1
                    while i < j and nums[i] == nums[i - 1]: 
                        i += 1
                elif s > 0:
                    j -= 1
                    while i < j and nums[j] == nums[j + 1]: 
                        j -= 1
                else:
                    res.append([nums[k], nums[i], nums[j]])
                    i += 1
                    j -= 1
                    while i < j and nums[i] == nums[i - 1]: 
                        i += 1
                    while i < j and nums[j] == nums[j + 1]: 
                        j -= 1
        return res

 

18. 四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + 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 = [], target = 0
输出：[]

思路：我根据上面三数之和改写的，再增加一层循环，且注意一下break条件和之前的有所不一样因为-5>-11 但是-5-4==-11,所以这个break发生了改变，可能还有其他好的思路，有空再去参看一下别人的写法

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        res, i = [], 0
        for i in range(len(nums) - 3):
            if nums[i] > target and target>=0: 
                break # 
            if i > 0 and nums[i] == nums[i - 1]: 
                continue # 2. skip the same `nums[k]`.
            for j in range(i+1,len(nums) - 2):
                if nums[j]+nums[i] > target and target>=0: 
                    break 
                if j > i+1 and nums[j] == nums[j - 1]: 
                    continue # 

                k, l = j + 1, len(nums) - 1
                while k < l: # 3. double pointer
                    s = nums[i] + nums[j] + nums[k] + nums[l]-target 
                    if s < 0:
                        k += 1
                        while k < l and nums[k] == nums[k - 1]: 
                            k += 1
                    elif s > 0:
                        l -= 1
                        while k < l and nums[l] == nums[l + 1]: 
                            l -= 1
                    else:
                        res.append([nums[i], nums[j], nums[k] , nums[l]])
                        k += 1
                        l -= 1
                        while k < l and nums[k] == nums[k - 1]: 
                            k += 1
                        while k < l and nums[l] == nums[l + 1]: 
                            l -= 1
                
        return res

 

167. 两数之和 II - 输入有序数组

给定一个已按照 升序排列  的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

 
示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
示例 2：

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

输入：numbers = [-1,0], target = -1
输出：[1,2]

思路：可以使用双循环，但是会超时，我就在第一个for循环里面增加一个break和continue条件，跑通了就不继续优化了

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(numbers)):
            if numbers[i]>target and target>=0:
                break
            if numbers[i]==numbers[i-1] and i>0:
                continue
            for j in range(i+1,len(numbers)):
                if numbers[i]+numbers[j]==target:
                     
                    return[i+1,j+1]
                    break