LeetCode第23天：理解巧算，事半功倍！

2023-12-17 12:25:18

LeetCode第23天：回旋镖的数量

问题：给定n个距离点m相等的点，可得到n*(n-1)个回旋镖。用哈希图存储key距离和value出现次数。

解决方案 ：

使用哈希图存储key距离和value出现次数。
遍历所有点，并计算每个点与其他点的距离。
将每个距离作为哈希表中的键，并将出现次数作为值。
遍历哈希表，并计算每个距离对应的回旋镖的数量。
将所有回旋镖的数量相加，即可得到总回旋镖的数量。

代码示例 ：

def number_of_boomerangs(points):
  """
  计算回旋镖的数量。

  参数：
    points: 点的列表。

  返回：
    回旋镖的数量。
  """

  # 创建哈希表。
  hash_table = {}

  # 遍历所有点。
  for point in points:
    # 计算每个点与其他点的距离。
    for other_point in points:
      if point == other_point:
        continue

      # 计算距离。
      distance = ((point[0] - other_point[0]) ** 2 + (point[1] - other_point[1]) **  2) ** 0.5

      # 将距离作为键，并将出现次数作为值添加到哈希表中。
      if distance not in hash_table:
        hash_table[distance] = 0
      hash_table[distance] += 1

  # 遍历哈希表，并计算每个距离对应的回旋镖的数量。
  total_boomerangs = 0
  for distance in hash_table:
    # 计算回旋镖的数量。
    num_boomerangs = hash_table[distance] * (hash_table[distance] - 1)

    # 将回旋镖的数量添加到总回旋镖的数量中。
    total_boomerangs += num_boomerangs

  # 返回总回旋镖的数量。
  return total_boomerangs


# 测试代码。
points = [(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1)]
num_boomerangs = number_of_boomerangs(points)
print(num_boomerangs)

输出：

LeetCode第23天：爬楼梯

问题：假设你正在爬楼梯。需要n步才能到达顶部。每次你可以爬1步或2步。有多少种不同的方法可以到达顶部？

解决方案 ：

使用动态规划来解决这个问题。
定义一个数组dp，其中dp[i]表示到达第i个楼梯的不同方法的数量。
初始条件是dp[0] = 1和dp[1] = 1。
对于第i个楼梯，有dp[i] = dp[i-1] + dp[i-2]。
这是因为到达第i个楼梯有两种方法：要么从第i-1个楼梯爬1步，要么从第i-2个楼梯爬2步。
因此，我们可以通过计算dp[n]来得到到达顶部不同方法的数量。

代码示例 ：

def climb_stairs(n):
  """
  计算到达顶部不同方法的数量。

  参数：
    n: 需要爬的楼梯数。

  返回：
    到达顶部不同方法的数量。
  """

  # 创建dp数组。
  dp = [0] * (n + 1)

  # 初始条件。
  dp[0] = 1
  dp[1] = 1

  # 遍历楼梯。
  for i in range(2, n + 1):
    # 计算到达第i个楼梯不同方法的数量。
    dp[i] = dp[i-1] + dp[i-2]

  # 返回到达顶部不同方法的数量。
  return dp[n]


# 测试代码。
n = 4
num_ways = climb_stairs(n)
print(num_ways)