LeetCode题解：极简搞懂五道热门算法题，通关取胜！

2024-02-09 12:34:19

解锁LeetCode难题之门

LeetCode作为全球闻名的算法竞赛平台，是程序员们磨练算法技能的绝佳场所。无论是初学者还是经验丰富的程序员，都能在这里找到适合自己的挑战。今天，我们将聚焦LeetCode上的五道热门算法题，为你提供清晰易懂的解题思路和详细的代码实现，助你轻松通关！

1. 题号945：最小增量使数组唯一

问题给定一个非负整数数组，找到使数组中每个元素唯一所需的最小增量。
思路解析：贪心算法的应用。对数组进行排序，然后依次检查每个元素是否与前一个元素相同。如果相同，则增加该元素的增量，直到使其与前一个元素不同。
代码实现：

def minIncrementForUnique(nums):
  """
  :type nums: List[int]
  :rtype: int
  """
  nums.sort()
  inc = 0
  for i in range(1, len(nums)):
    if nums[i] <= nums[i - 1]:
      inc += nums[i - 1] - nums[i] + 1
      nums[i] = nums[i - 1] + 1
  return inc

2. 题号742：二叉树最近叶节点间距离

问题：给定一棵二叉树，找到两个叶节点之间的最短路径长度。
思路解析：利用动态规划，分别计算每个节点到其左子树和右子树的最长路径长度，然后取最大值作为该节点到其最近叶节点的距离。
代码实现：

def findClosestLeaf(root):
  """
  :type root: TreeNode
  :rtype: int
  """
  if not root:
    return 0
  
  def dfs(node):
    if not node:
      return float('inf')
    
    if not node.left and not node.right:
      return 0
    
    left = dfs(node.left)
    right = dfs(node.right)
    
    if node.left and node.right:
      return min(left, right) + 1
    elif node.left:
      return left + 1
    else:
      return right + 1
  
  return dfs(root)

3. 题号721：账户合并

问题：给定一个字符串数组，每个字符串包含一个电子邮件地址和一个姓名，将所有具有相同电子邮件地址的字符串合并为一个字符串，并按姓名排序。
思路解析：利用哈希表存储电子邮件地址和姓名的映射关系，然后将具有相同电子邮件地址的字符串添加到一个列表中，最后对列表中的字符串按姓名排序。
代码实现：

def accountsMerge(accounts):
  """
  :type accounts: List[List[str]]
  :rtype: List[List[str]]
  """
  email_to_name = {}
  email_to_accounts = {}
  
  for account in accounts:
    email = account[0]
    name = account[1]
    email_to_name[email] = name
    if email not in email_to_accounts:
      email_to_accounts[email] = []
    email_to_accounts[email].append(account)
  
  merged_accounts = []
  for email, accounts in email_to_accounts.items():
    accounts.sort(key=lambda account: account[1])
    merged_accounts.append([email_to_name[email]] + [account[1] for account in accounts])
  
  return merged_accounts

4. 题号662：二叉树最大宽度

问题描述：给定一棵二叉树，求二叉树的最大宽度。二叉树的最大宽度定义为二叉树中最宽的一层的宽度。
思路解析：利用广度优先搜索，每一层使用一个队列来存储节点，并计算该层的宽度。
代码实现：

def maxWidthOfBinaryTree(root):
  """
  :type root: TreeNode
  :rtype: int
  """
  if not root:
    return 0
  
  max_width = 0
  queue = [(root, 1)]
  
  while queue:
    level_size = len(queue)
    max_width = max(max_width, level_size)
    for i in range(level_size):
      node, index = queue.pop(0)
      if node.left:
        queue.append((node.left, index * 2))
      if node.right:
        queue.append((node.right, index * 2 + 1))
  
  return max_width

5. 题号437：路径总和 III

问题描述：给定一棵二叉树和一个目标值，求二叉树中所有从根节点到叶节点的路径之和等于目标值的路径条数。
思路解析：利用深度优先搜索，分别计算每个节点到其左右子树的路径之和，然后判断是否等于目标值。
代码实现：

def pathSum(root, targetSum):
  """
  :type root: TreeNode
  :type targetSum: int
  :rtype: int
  """
  if not root:
    return 0
  
  def dfs(node, path_sum):
    if not node:
      return 0
    
    path_sum += node.val
    path_count = 0
    if path_sum == targetSum:
      path_count += 1
    
    path_count += dfs(node.left, path_sum)
    path_count += dfs(node.right, path_sum)
    
    path_sum -= node.val
    return path_count
  
  return dfs(root, 0)