手速挑战：LeetCode 周赛 335 题目详解与解法指南

见解分享

2023-10-13 14:49:16

LeetCode 第 335 场周赛：详解与指南

引言：

欢迎来到 LeetCode 第 335 场周赛的详解与指南。在本指南中，我们将深入探讨本次周赛中的每一题，提供详细的解决方案和代码示例，帮助您全面理解周赛题目。

2582. 递枕头（Easy）

问题

我们有一个传递枕头的游戏，共有 n 个人参与，第 i 个人传递枕头所需的时间为 passTimes[i]。当某人收到枕头时，他们必须花费 passTimes[i] 的时间才能将其传递给下一个人。

目标是找出最少的时间，让枕头从第一个人传递到第 n 个人。

解决方案：

我们可以将此问题视为一个滑动窗口问题。我们定义滑动窗口的大小为 k，从头开始遍历数组。当窗口中所有元素的和大于等于目标值 target 时，我们可以将窗口向右移动一步。否则，我们递增窗口大小并继续遍历数组。

代码示例：

def handoff(target, passTimes):
    """
    :type target: int
    :type passTimes: List[int]
    :rtype: int
    """
    n = len(passTimes)
    i, j, sum = 0, 0, 0
    res = n + 1
    while j < n:
        sum += passTimes[j]
        while sum >= target:
            res = min(res, j - i + 1)
            sum -= passTimes[i]
            i += 1
        j += 1
    return res if res != n + 1 else -1

2583. 缩小后的最大重复子串（Medium）

问题：

给定一个字符串 s，我们要找到一个子串，可以重复任意次，并且重复后的长度最长。

解决方案：

我们可以使用动态规划来解决这个问题。我们定义 dp[i][j] 为字符串 s[0:i] 和 s[j:len(s)] 的最长重复子串的长度。然后，我们可以使用以下状态转移方程来求解 dp 数组：

dp[i][j] = dp[i + 1][j + 1] + 1  if s[i] == s[j]
          = 0                   otherwise

代码示例：

def maxRepeating(s):
    """
    :type s: str
    :rtype: int
    """
    n = len(s)
    dp = [[0] * (n + 1) for _ in range(n + 1)]
    for i in range(n - 1, -1, -1):
        for j in range(n):
            if s[i] == s[j]:
                dp[i][j] = dp[i + 1][j + 1] + 1
    maxLen = 0
    for i in range(n):
        for j in range(n):
            maxLen = max(maxLen, dp[i][j])
    return maxLen

2584. 考试的最大困扰度（Medium）

问题：

我们有一系列任务需要完成，每个任务都有一个难度值。我们要安排这些任务的顺序，使得任务序列的难度之和最小。任务的难度可以重复。

解决方案：

我们可以将此问题视为一个动态规划问题。我们定义 dp[i][j] 为前 i 个任务，难度之和不超过 j 的最小难度之和。然后，我们可以使用以下状态转移方程来求解 dp 数组：

dp[i][j] = min(dp[k - 1][j - 1] + max(tasks[k - 1], tasks[k], ..., tasks[i]))  for k in range(1, i + 1)

代码示例：

def minDifficulty(tasks, d):
    """
    :type tasks: List[int]
    :type d: int
    :rtype: int
    """
    n = len(tasks)
    if n < d:
        return -1
    dp = [[float('inf')] * (d + 1) for _ in range(n + 1)]
    dp[0][0] = 0
    for i in range(1, n + 1):
        for j in range(1, d + 1):
            dp[i][j] = dp[i - 1][j]
            maxDiff = 0
            for k in range(i, 0, -1):
                maxDiff = max(maxDiff, tasks[k - 1])
                dp[i][j] = min(dp[i][j], dp[k - 1][j - 1] + maxDiff)
    return dp[n][d] if dp[n][d] != float('inf') else -1

2585. 迷宫中的路径（Hard）

问题描述：

给定一个迷宫，我们必须从迷宫的左上角走到右下角。迷宫中的每个单元格都有一个高度值，我们必须找到一条路径，使得路径上的努力值最小。努力值定义为相邻两个单元格高度差的绝对值。

解决方案：

我们可以使用 Dijkstra 算法来解决这个问题。算法步骤如下：

将左上角单元格添加到优先队列中，努力值为 0。
从优先队列中取出努力值最小的单元格。
检查单元格的相邻单元格，如果单元格不在优先队列中或单元格的努力值大于相邻单元格的努力值，则将相邻单元格添加到优先队列中，并更新其努力值。
重复步骤 2 和 3，直到到达右下角单元格。

代码示例：

import heapq

def minimumEffortPath(heights):
    """
    :type heights: List[List[int]]
    :rtype: int
    """
    m, n = len(heights), len(heights[0])
    dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    pq = [(0, 0, 0)]
    visited = set()
    while pq:
        effort, i, j = heapq.heappop(pq)
        if (i, j) == (m - 1, n - 1):
            return effort
        if (i, j) in visited:
            continue
        visited.add((i, j))
        for dx, dy in dirs:
            x, y = i + dx, j + dy
            if 0 <= x < m and 0 <= y < n and (x, y) not in visited:
                newEffort = max(effort, abs(heights[i][j] - heights[x][y]))
                heapq.heappush(pq, (newEffort, x, y))
    return -1