leetcode专项刷题_数组（2）_两数之和/访问所有点的最小时间/统计有序矩阵中的负数/种花问题

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

题目解释

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2

代码实现

# numbers = [2, 7, 11, 15], target = 9   >> [1,2]  >> 解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2

class Solution:
		# 暴力阶解法
    for index in range(len(numbers) - 1):
      if (target - numbers[index]) in numbers[index + 1:]:
        if target - numbers[index] == numbers[index]:
          return index + 1, index + 2
        return index + 1, numbers.index(target - numbers[index]) + 1
    
    # 双指针
    # 思路:有序一般都会考虑双指针的算法，那么这个就考虑通过中间值和target判断大小，减少判断次数，提高性能
    def twoSum(self, numbers, target):
        left, right = 0, len(numbers) - 1
        while left < right:
            if numbers[left] + numbers[right] > target:
                right -= 1
            elif numbers[left] + numbers[right] < target:
                left += 1
            else:
                return left + 1, right + 1
        return -1, -1
    

访问所有点的最小时间

题目解释

平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）。

你可以按照下面的规则在平面上移动：

每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
必须按照数组中出现的顺序来访问这些点。

         y|3
          |2
          |1
          |
--------------------->x
          |0  1  2  3  
          |	
          |
          |

############ 类似这种坐标点，找最短路径 ################

输入：points = [[1,1],[3,4],[-1,0]]
输出：7
解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]   
从 [1,1] 到 [3,4] 需要 3 秒 
从 [3,4] 到 [-1,0] 需要 4 秒
一共需要 7 秒

输入：points = [[3,2],[-2,2]]
输出：5

代码实现

# 说白了，通过画图思考，发现其实最短距离就是每次移动的坐标值（x, y）之差的绝对值,哪个大就取哪个，于是尝试确实	如此
class Solution:
    def minTimeToVisitAllPoints(self, points):
        count = 0
        for point in range(len(points) - 1):
            previous_x, previous_y = points[point][0], points[point][1]
            current_x, current_y = points[point + 1][0], points[point + 1][1]
            count += max(abs(current_x - previous_x), abs(current_y - previous_y))
        return count
      
# 官方题解
# 方法一：切比雪夫距离
# 对于平面上的两个点 x = (x0, x1) 和 y = (y0, y1)，设它们横坐标距离之差为 dx = |x0 - y0|，纵坐标距离之           差为 dy = |x1 - y1|，对于以下三种情况，我们可以分别计算出从 x 移动到 y 的最少次数：

# dx < dy：沿对角线移动 dx 次，再竖直移动 dy - dx 次，总计 dx + (dy - dx) = dy 次；

# dx == dy：沿对角线移动 dx 次；

# dx > dy：沿对角线移动 dy 次，再水平移动 dx - dy 次，总计 dy + (dx - dy) = dx 次。

# 可以发现，对于任意一种情况，从 x 移动到 y 的最少次数为 dx 和 dy 中的较大值 max(dx, dy)，这也被称作 x 和 y 之间的 切比雪夫距离。

# 由于题目要求，需要按照数组中出现的顺序来访问这些点。因此我们遍历整个数组，对于数组中的相邻两个点，计算出它们的切比雪夫距离，所有的距离之和即为答案。
class Solution:
    def minTimeToVisitAllPoints(self, points: List[List[int]]) -> int:
        x0, x1 = points[0]
        ans = 0
        for i in range(1, len(points)):
            y0, y1 = points[i]
            ans += max(abs(x0 - y0), abs(x1 - y1))
            x0, x1 = points[i]
        return ans

统计有序矩阵中的负数

题目解释

给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。

请你统计并返回 grid 中 负数 的数目。

代码实现

# grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]] >> 8
# grid = [[3,2],[1,0]]   >> 0

# 因为是递减序列，所以最后一个值一定是最小的，如果最小的都大于0，则不需要遍历了，还有就是如果存在小于1的数字，    则碰到大于0的就直接退出，面得浪费性能，所以要从最后往前遍历，一行一行的遍历就行了
class Solution:
    def countNegatives(self, grid):
        count = 0
        for row_index in range(len(grid) - 1, -1, -1):
            for column_index in range(len(grid[row_index]) - 1, -1, -1):
                if grid[row_index][column_index] < 0:
                    count += 1
                else:
                    break
        return count
      

种花问题

题目解释

假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False

代码实现

# 这个方法确实不是我想出来的，我光在判断两端值的方向上奋斗了，这个真的秀, 添加表头表尾为0，假设没有花，以此判断原表中每个位置的情况
class Solution:
    def canPlaceFlowers(self, flowerbed, n):
        flowerbed = [0] + flowerbed + [0]
        # 这个才是原表需要计算的范围
        for i in range(1, len(flowerbed) - 1):
          	# 构建了两端值之后就只需要判断是否连续的3个0即可，妙！
            if flowerbed[i - 1] == 0 and flowerbed[i] == 0 and flowerbed[i + 1] == 0:
                n -= 1
        return n <= 0

检查整数及其两倍数是否存在

题目解释

给你一个整数数组 arr，请你检查是否存在两个整数 N 和 M，满足 N 是 M 的两倍（即，N = 2 * M）。

解释: 更正式地，检查是否存在两个下标 i 和 j 满足：
i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]


输入：arr = [10,2,5,3]
输出：true
解释：N = 10 是 M = 5 的两倍，即 10 = 2 * 5 

输入：arr = [3,1,7,11]
输出：false
解释：在该情况下不存在 N 和 M 满足 N = 2 * M

实现代码

# 将原表每个值处以2的结果和原表数据进行对比，两种情况
# 1.如果两个表中存在相同数据，且原表中只有一个值且这个值的索引和原表索引不一致
# 2.如果两个表中存在相同数据，且原表中存在至少两个相同的值，那么就代表着一定是有匹配的值，不需判断是否索引相等
class Solution:
    def checkIfExist(self, arr):
        new_arr = [i / 2 for i in arr]
        for i in range(len(new_arr)):
            if new_arr[i] in arr:
                if (arr.count(new_arr[i]) == 1 and arr[i] != new_arr[i]) or arr.count(new_arr[i]) > 1:
                    return True
        return False