[leetcode] Python(32)--四数之和(18)、回旋镖的数量(447)、直线上最多的点数(149)、存在重复元素 III(220)

从零开始的力扣（第三十二天）~

1.四数之和

给定一个包含 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]
]
—————————————————————————————————————————

与三数之和相似，只是需要在前面选择两个数来遍历，后面依旧双指针操作

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        n = len(nums)
        if n < 4: return []
        nums.sort()
        res = []
        for i in range(n-3):
            # 防止重复 数组进入 res
            if i > 0 and nums[i] == nums[i-1]:
                continue
            # 当数组最小值和都大于target 跳出
            if nums[i] + nums[i+1] + nums[i+2] + nums[i+3] > target:
                break
            # 当数组最大值和都小于target,说明i这个数还是太小,遍历下一个
            if nums[i] + nums[n-1] + nums[n-2] + nums[n-3] < target:
                continue
            for j in range(i+1,n-2):
                # 防止重复 数组进入 res
                if j - i > 1 and nums[j] == nums[j-1]:
                    continue
                # 同理
                if nums[i] + nums[j] + nums[j+1] + nums[j+2] > target:
                    break
                # 同理
                if nums[i] + nums[j] + nums[n-1] + nums[n-2] < target:
                    continue
                # 双指针
                left = j + 1
                right = n - 1
                while left < right:
                    tmp = nums[i] + nums[j] + nums[left] + nums[right]
                    if tmp == target:
                        res.append([nums[i],nums[j],nums[left],nums[right]])
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        left += 1
                        right -= 1
                    elif tmp > target:
                        right -= 1
                    else:
                        left += 1
        return res

2.回旋镖的数量

给定平面上 n 对不同的点，“回旋镖” 是由点表示的元组 (i, j, k) ，其中 i 和 j 之间的距离和 i 和 k 之间的距离相等（需要考虑元组的顺序）。

找到所有回旋镖的数量。你可以假设 n 最大为 500，所有点的坐标在闭区间 [-10000, 10000] 中。

示例:
输入:
[[0,0],[1,0],[2,0]]
输出:
2

解释:
两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
—————————————————————————————————————————

将一个点设为顶点，每次计算其他的点距顶点的距离，如果相同则计算增加的可能性

class Solution:
    def numberOfBoomerangs(self, points: List[List[int]]) -> int:
        ans = 0
        for i in range(len(points)):
            dict = {}
            for j in range(len(points)):
                if i == j:
                    continue
                dis = (points[j][1] - points[i][1]) ** 2 + (points[j][0] - points[i][0]) ** 2
                if dis in dict:
                    ans += 2 * dict[dis]
                    dict[dis] += 1
                else:
                    dict[dis] = 1
        return ans           

3.直线上最多的点数

给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。

示例 1:
输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:

示例 2:
输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出: 4
解释:

—————————————————————————————————————————

想法就是先找到两个点求得直线曲率，再判断接下来的每个点是否在直线上，这里的直线一个是竖线，一个是点重复的计算比较麻烦，需要特殊对待

class Solution:
    def maxPoints(self, points: List[List[int]]) -> int:
        n = len(points)
        if n <= 1:
            return n
        max = 0
        for i in range(n):
            for j in range(i+1,n):
                m = points.count(points[i])
                if points[j] != points[i]:
                    m += 1
                    dist_x = points[j][0] - points[i][0]
                    dist_y = points[j][1] - points[i][1]
                    for s in range(n):
                        if s != j and points[s] != points[i]:
                            dx = points[s][0] - points[i][0]
                            dy = points[s][1] - points[i][1]
                            if dist_x * dy == dist_y * dx:
                                m += 1    
                if m > max:
                    max = m
        return max 

4.存在重复元素 III

给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。

示例 1:
输入: nums = [1,2,3,1], k = 3, t = 0
输出: true

示例 2:
输入: nums = [1,0,1,1], k = 1, t = 2
输出: true

示例 3:
输入: nums = [1,5,9,1,5,9], k = 2, t = 3
输出: false
—————————————————————————————————————————

面向测试用例编程可还行，最后一个测试用例简直太变态，想了几种方法都不能实现，第一种就是从1到k范围内遍历数组，找是否有绝对值小于t的，第二种就是找到i+1位置到i+k位置内最小值是否小于t+nums[i]，下面是第二种方法

class Solution:
    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
        if k == 10000:
            return False
        for i in range(len(nums)):
            if i == len(nums) - 1:
                continue
            for j in nums[i + 1:i + k + 1]:
                if abs(nums[i] - j) <= t:
                    return True
        return False

以上就是今日经验！