深入探索 LeetCode18 四数之和 | 刷题打卡的解题策略与要点

2023-12-20 15:32:53

深入解析 LeetCode 18 四数之和：破解难题的最佳策略

前言

LeetCode 18 四数之和问题是一个经典的面试难题，要求你找到给定数组中所有满足特定和的四元组。解决这个问题需要深入的算法理解和高效的数据结构。在本文中，我们将探讨两种解决此问题的有效策略，并提供详细的代码实现。

算法简介

策略 1：将三数之和问题转化为两数之和问题

这个策略的精髓在于将四数之和问题分解成更小的子问题。首先，我们将四数之和问题转化为三个数之和与一个数之和的问题。使用现有的三数之和算法，我们可以有效地找到满足条件的三元组。然后，我们可以利用这些三元组，通过两数之和算法找到满足目标和的四元组。

策略 2：利用哈希表存储已经计算过的结果

为了避免重复计算，我们可以利用哈希表存储已经计算过的结果。这样，在计算下一个四元组时，我们可以快速判断该四元组是否已经计算过，从而避免不必要的重复计算。

算法步骤

策略 1

对给定数组进行排序。
使用双指针算法寻找满足条件的三元组。
利用哈希表存储已经计算过的三元组。
使用哈希表寻找满足条件的四元组。

策略 2

对给定数组进行排序。
使用双指针算法和哈希表寻找满足条件的三元组。
使用双指针算法和哈希表寻找满足条件的四元组。

代码示例

def fourSum(nums, target):
    """
    Finds all unique quadruplets in the array that sum up to the target.

    Args:
        nums: A list of integers.
        target: The target sum.

    Returns:
        A list of lists of four integers representing all unique quadruplets.
    """
    # Sort the array.
    nums.sort()

    # Create a set to store the unique quadruplets.
    quadruplets = set()

    # Iterate over the array.
    for i in range(len(nums) - 3):
        # Check if the current element is the same as the previous element.
        if i > 0 and nums[i] == nums[i - 1]:
            continue

        # Find all unique three-sums that sum up to the target - nums[i].
        three_sum_target = target - nums[i]
        three_sum_results = find_three_sum(nums[i + 1:], three_sum_target)

        # Iterate over the three-sum results.
        for three_sum_result in three_sum_results:
            # Add the current quadruplet to the set.
            quadruplets.add((nums[i],) + three_sum_result)

    # Return the list of unique quadruplets.
    return list(quadruplets)


def find_three_sum(nums, target):
    """
    Finds all unique triplets in the array that sum up to the target.

    Args:
        nums: A list of integers.
        target: The target sum.

    Returns:
        A list of lists of three integers representing all unique triplets.
    """
    # Create a set to store the unique triplets.
    triplets = set()

    # Iterate over the array.
    for i in range(len(nums) - 2):
        # Check if the current element is the same as the previous element.
        if i > 0 and nums[i] == nums[i - 1]:
            continue

        # Find all unique two-sums that sum up to the target - nums[i].
        two_sum_target = target - nums[i]
        two_sum_results = find_two_sum(nums[i + 1:], two_sum_target)

        # Iterate over the two-sum results.
        for two_sum_result in two_sum_results:
            # Add the current triplet to the set.
            triplets.add((nums[i],) + two_sum_result)

    # Return the list of unique triplets.
    return list(triplets)


def find_two_sum(nums, target):
    """
    Finds all unique pairs in the array that sum up to the target.

    Args:
        nums: A list of integers.
        target: The target sum.

    Returns:
        A list of lists of two integers representing all unique pairs.
    """
    # Create a set to store the unique pairs.
    pairs = set()

    # Create a set to store the seen numbers.
    seen = set()

    # Iterate over the array.
    for num in nums:
        # Check if the complement of the current number is in the seen set.
        complement = target - num
        if complement in seen:
            # Add the current pair to the set.
            pairs.add((min(num, complement), max(num, complement)))

        # Add the current number to the seen set.
        seen.add(num)

    # Return the list of unique pairs.
    return list(pairs)