力扣组队刷题打卡第四次

二. 对撞指针

LeetCode 1 Two Sum

题目描述

给出一个整型数组nums，返回这个数组中两个数字的索引值i和j，使得nums[i] + nums[j]等于一个给定的target值，两个索引不能相等。

如：nums= [2,7,11,15],target=9
返回[0,1]

审题:

需要考虑：

1. 开始数组是否有序；
2. 索引从0开始计算还是1开始计算？
3. 没有解该怎么办？
4. 有多个解怎么办？保证有唯一解。

分析实现

暴力法O(n^2)

时间复杂度为O(n^2),第一遍遍历数组，第二遍遍历当前遍历值之后的元素，其和等于target则return。

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

排序+指针对撞(O(n)+O(nlogn)=O(n))

在数组篇的LeetCode 167题中，也遇到了找到两个数使得它们相加之和等于目标数，但那是对于排序的情况，因此也可以使用上述的思路来完成。

因为问题本身不是有序的，因此需要对原来的数组进行一次排序，排序后就可以用O(n)的指针对撞进行解决。

但是问题是，返回的是数字的索引，如果只是对数组的值进行排序，那么数组原来表示的索引的信息就会丢失，所以在排序前要进行些处理。

错误代码示例–只使用dict来进行保存：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()
        for index in range(len(nums)):
            record[nums[index]] = index 
        nums.sort()
        l,r = 0,len(nums)-1
        while l < r:
            if nums[l] + nums[r] == target:
                return [record[nums[l]],record[nums[r]]]
            elif nums[l] + nums[r] < target:
                l += 1
            else:
                r -= 1

当遇到相同的元素的索引问题时，会不满足条件：

如：[3,3] 6

在排序前先使用一个额外的数组拷贝一份原来的数组，对于两个相同元素的索引问题，使用一个bool型变量辅助将两个索引都找到，总的时间复杂度为O(n)+O(nlogn) = O(nlogn)

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()
        nums_copy = nums.copy()
        sameFlag = True;
        nums.sort()
        l,r = 0,len(nums)-1
        while l < r:
            if nums[l] + nums[r] == target:
                break
            elif nums[l] + nums[r] < target:
                l += 1
            else:
                r -= 1
        res = []
        for i in range(len(nums)):
            if nums_copy[i] == nums[l] and sameFlag:
                res.append(i)
                sameFlag = False
            elif nums_copy[i] == nums[r]:
                res.append(i)
        return res

小套路:

如果只是对数组的值进行排序，那么数组原来表示的索引的信息就会丢失的情况，可以在排序前：

更加pythonic的实现

通过list(enumerate(nums))开始实现下标和值的绑定，不用专门的再copy加bool判断。

nums = list(enumerate(nums))
nums.sort(key = lambda x:x[1])
i,j = 0, len(nums)-1
while i < j:
    if nums[i][1] + nums[j][1] > target:
        j -= 1
    elif nums[i][1] + nums[j][1] < target:
        i += 1
    else:
        if nums[j][0] < nums[i][0]:
            nums[j],nums[i] = nums[i],nums[j]
        return num[i][0],nums[j][0]

拷贝数组 + bool型变量辅助

查找表–O(n)

遍历数组过程中，当遍历到元素v时，可以只看v前面的元素，是否含有target-v的元素存在。

1. 如果查找成功，就返回解；
2. 如果没有查找成功，就把v放在查找表中，继续查找下一个解。

即使v放在了之前的查找表中覆盖了v，也不影响当前v元素的查找。因为只需要找到两个元素，只需要找target-v的另一个元素即可。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()
        for i in range(len(nums)):
            complement = target - nums[i]
            # 已经在之前的字典中找到这个值
            if record.get(complement) is not None:
                res = [i,record[complement]]
                return res
            record[nums[i]] = i

只进行一次循环，故时间复杂度O(n),空间复杂度为O(n)

补充思路：

通过enumerate来把索引和值进行绑定，进而对value进行sort，前后对撞指针进行返回。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        nums = list(enumerate(nums))
        # 根据value来排序
        nums.sort(key = lambda x:x[1])
        l,r = 0, len(nums)-1
        while l < r:
            if nums[l][1] + nums[r][1] == target:
                return nums[l][0],nums[r][0]
            elif nums[l][1] + nums[r][1] < target:
                l += 1
            else:
                r -= 1

LeetCode 15 3Sum

题目描述

给出一个整型数组，寻找其中的所有不同的三元组(a,b,c)，使得a+b+c=0

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

如：nums = [-1, 0, 1, 2, -1, -4]，

结果为：[[-1, 0, 1],[-1, -1, 2]]

审题

1. 数组不是有序的；
2. 返回结果为全部解，多个解的顺序是否需要考虑？–不需要考虑顺序
3. 什么叫不同的三元组？索引不同即不同，还是值不同？–题目定义的是，值不同才为不同的三元组
4. 没有解时怎么返回？–空列表

分析实现

因为上篇中已经实现了Two Sum的问题，因此对于3Sum，首先想到的思路就是，开始固定一个k，然后在其后都当成two sum问题来进行解决，但是这样就ok了吗？

没有考虑重复元素导致错误

直接使用Two Sum问题中的查找表的解法，根据第一层遍历的i，将i之后的数组作为two sum问题进行解决。

class Solution:
    def threeSum(self, nums: [int]) -> [[int]]:
        res = []
        for i in range(len(nums)):
            num = 0 - nums[i]
            record = dict()
            for j in range(i + 1, len(nums)):
                complement = num - nums[j]
                # 已经在之前的字典中找到这个值
                if record.get(complement) is not None:
                    res_lis = [nums[i], nums[j], complement]
                    res.append(res_lis)
                record[nums[j]] = i
        return res

但是这样会导致一个错误，错误用例如下:

输入：
[-1,0,1,2,-1,-4]
输出：
[[-1,1,0],[-1,-1,2],[0,-1,1]]
预期结果：
[[-1,-1,2],[-1,0,1]]

代码在实现的过程中没有把第一次遍历的i的索引指向相同元素的情况排除掉，于是出现了当i指针后面位置的元素有和之前访问过的相同的值，于是重复遍历。

那么可以考虑，开始时对nums数组进行排序，排序后，当第一次遍历的指针k遇到下一个和前一个指向的值重复时，就将其跳过。为了方便计算，在第二层循环中，可以使用对撞指针的套路：

# 对撞指针套路
l,r = 0, len(nums)-1
while l < r:
    if nums[l] + nums[r] == target:
        return nums[l],nums[r]
    elif nums[l] + nums[r] < target:
        l += 1
    else:
        r -= 1

其中需要注意的是，在里层循环中，也要考虑重复值的情况，因此当值相等时，再次移动指针时，需要保证其指向的值和前一次指向的值不重复，因此可以：

# 对撞指针套路
l,r = 0, len(nums)-1
while l < r:
    sum = nums[i] + nums[l] + nums[r]
    if sum == target:
        res.append([nums[i],nums[l]