LeetCode 周赛 334：在算法的世界里反复横跳

见解分享

2024-01-19 20:08:31

LeetCode 第 334 场周赛：基础知识点大扫除

简介

欢迎来到 LeetCode 第 334 场周赛！这场周赛以其基础的算法知识点和平均的难度而闻名，其中第四题的独特“反复横跳”算法实现令人印象深刻。

考察范围

这场周赛考察了以下核心算法知识点：

树的遍历
图的遍历
贪心算法
动态规划

题目难度分析

本场周赛的题目难度分布如下：

第 1 题：困难
第 2 题：中等
第 3 题：中等
第 4 题：中等

题目详解

第 1 题：二叉树路径

这道题考察了二叉树遍历，要求我们找到二叉树中从根节点到所有叶节点的路径。可以使用深度优先搜索（DFS）来遍历树并记录路径。

代码示例：

def binaryTreePaths(root):
  if not root:
    return []

  paths = []
  stack = [(root, [str(root.val)])]

  while stack:
    node, path = stack.pop()

    if not node.left and not node.right:
      paths.append('->'.join(path))
    else:
      if node.left:
        stack.append((node.left, path + [str(node.left.val)]))
      if node.right:
        stack.append((node.right, path + [str(node.right.val)]))

  return paths

第 2 题：最大距离内城市的子树计数

这道题结合了图的遍历和贪心算法，要求我们找到一棵树中距离最远的两个节点之间的距离。我们可以使用深度优先搜索（DFS）遍历树，并记录每个节点到其他所有节点的距离。

代码示例：

def countSubtreesWithMaxDistanceBetweenCities(n, edges):
  graph = defaultdict(list)
  for a, b in edges:
    graph[a].append(b)
    graph[b].append(a)

  diameter = 0

  def dfs(node, parent):
    nonlocal diameter

    distance = [0] * (n + 1)
    visited = [False] * (n + 1)

    queue = [(node, 0)]
    while queue:
      curr, dist = queue.pop(0)
      visited[curr] = True
      distance[curr] = dist

      for neighbor in graph[curr]:
        if not visited[neighbor]:
          queue.append((neighbor, dist + 1))

    max_distance = 0
    max_node = -1
    for i in range(1, n + 1):
      if distance[i] > max_distance:
        max_distance = distance[i]
        max_node = i

    diameter = max(diameter, max_distance)

    return max_node

  dfs(1, 1)

  return diameter

第 3 题：给花园浇水所需的最少水龙头数量

这道题考察了动态规划，要求我们找到最少需要打开多少个水龙头，才能浇灌整个花园。我们可以定义一个状态 dp[i]，表示浇灌前 i 米的花园所需的最少水龙头数量。

代码示例：

def minTaps(n, ranges):
  dp = [float('inf')] * (n + 1)
  dp[0] = 0

  for i in range(1, n + 1):
    for j, r in enumerate(ranges):
      if i <= j + r:
        dp[i] = min(dp[i], dp[max(0, i - r)] + 1)

  return dp[n] if dp[n] != float('inf') else -1

第 4 题：奇偶跳跃

这道题是一个独特的动态规划问题，要求我们找到从索引 0 开始，可以按照奇偶顺序到达数组末尾的最长路径的长度。我们可以定义一个状态 dp[i][0]，表示从索引 i 开始，按照奇数索引顺序到达数组末尾的最长路径的长度。

代码示例：

def oddEvenJumps(arr):
  n = len(arr)
  odd = [False] * n
  even = [False] * n

  odd[n - 1] = True
  even[n - 1] = True

  for i in range(n - 2, -1, -1):
    idx_odd = i + 1
    idx_even = i + 1

    while idx_odd < n and arr[idx_odd] < arr[i]:
      idx_odd += 1

    if idx_odd < n:
      odd[i] = even[idx_odd]

    while idx_even < n and arr[idx_even] > arr[i]:
      idx_even += 1

    if idx_even < n:
      even[i] = odd[idx_even]

  return sum(odd)