哈希表与双指针算法实战：从两数之和到四数之和

1. 哈希表实战：从两数之和到四数之和的算法精解

哈希表（Hash Table）作为数据结构中的瑞士军刀，在算法面试和实际工程中都有着举足轻重的地位。今天我将通过四道经典力扣题目，带你深入掌握哈希表在不同场景下的应用技巧。这些题目看似简单，但其中蕴含的优化思路和边界条件处理，正是区分普通程序员和算法高手的试金石。

2. 四数相加II：分组哈希的巧妙应用

2.1 问题重述与暴力解法分析

给定四个整数数组A、B、C、D，我们需要统计有多少个元组(i,j,k,l)满足A[i] + B[j] + C[k] + D[l] = 0。最直观的暴力解法是四重循环，时间复杂度高达O(N^4)，当N=500时，这将导致625亿次运算，显然不可行。

2.2 哈希优化思路

关键突破点在于将问题转化为两组两数之和的问题：

1. 先计算A和B中所有可能的和及其出现次数，存入哈希表
2. 再计算C和D中所有可能的和的相反数，查询哈希表

这种"分治+哈希"的思路将时间复杂度从O(N^4)降低到O(N^2)，空间复杂度为O(N^2)。

2.3 代码实现与细节处理

python复制def fourSumCount(nums1, nums2, nums3, nums4):
    hashmap = {}
    # 统计前两组元素的和
    for n1 in nums1:
        for n2 in nums2:
            sum_ab = n1 + n2
            hashmap[sum_ab] = hashmap.get(sum_ab, 0) + 1
    
    count = 0
    # 查询后两组元素的相反数和
    for n3 in nums3:
        for n4 in nums4:
            target = - (n3 + n4)
            count += hashmap.get(target, 0)
    return count

关键细节：使用hashmap.get(key, default)方法可以避免键不存在的KeyError，保持代码简洁。

2.4 复杂度分析与适用场景

• 时间复杂度：O(N^2)，两个嵌套循环
• 空间复杂度：O(N^2)，最坏情况下所有A+B的和都不同
• 适用场景：当需要统计多个数组元素组合满足某种关系时，分组哈希是常用技巧

3. 赎金信：字符频率统计的经典案例

3.1 问题理解与边界条件

给定两个字符串ransomNote和magazine，判断ransomNote是否能由magazine中的字符组成。注意：

1. magazine中的每个字符只能使用一次
2. 只考虑小写字母
3. ransomNote长度大于magazine时直接返回False

3.2 哈希表解法实现

python复制def canConstruct(ransomNote, magazine):
    if len(ransomNote) > len(magazine):
        return False
    
    char_count = [0] * 26  # 使用数组替代哈希表，效率更高
    for c in magazine:
        char_count[ord(c) - ord('a')] += 1
    
    for c in ransomNote:
        index = ord(c) - ord('a')
        if char_count[index] == 0:
            return False
        char_count[index] -= 1
    
    return True

3.3 优化技巧与变种问题

1. 使用固定长度数组代替哈希表：当字符集确定且较小时（如仅小写字母），数组访问比哈希表更快
2. 提前终止：当发现某个字符不足时立即返回，不必完成全部统计
3. 变种问题：考虑Unicode字符时的解决方案（需要使用真正的哈希表）

4. 三数之和：双指针与去重艺术

4.1 为什么哈希法不是最佳选择

虽然可以使用哈希法解决三数之和问题，但面临两个主要挑战：

1. 去重困难：需要额外数据结构记录已使用的三元组
2. 剪枝有限：无法有效利用排序带来的信息

4.2 双指针法的精妙之处

1. 先排序：O(NlogN)的排序为后续双指针创造条件
2. 固定一个数，转化为两数之和问题
3. 利用有序性移动指针：和小于目标移动左指针，大于目标移动右指针

4.3 代码实现与去重技巧

python复制def threeSum(nums):
    nums.sort()
    result = []
    n = len(nums)
    
    for i in range(n - 2):
        if nums[i] > 0:  # 提前终止
            break
        if i > 0 and nums[i] == nums[i-1]:  # 外层去重
            continue
            
        left, right = i + 1, n - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total < 0:
                left += 1
            elif total > 0:
                right -= 1
            else:
                result.append([nums[i], nums[left], nums[right]])
                # 内层去重
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
    return result

去重关键：在外层循环跳过相同元素，在内层找到解后也要跳过相同元素

4.4 时间复杂度分析

• 排序：O(NlogN)
• 双指针部分：O(N^2)
• 总体：O(N^2)，比哈希法的O(N^2)更优，因为实际运行中剪枝更多

5. 四数之和：双指针的进阶应用

5.1 从三数之和到四数之和

四数之和可以看作在三数之和的基础上再加一层循环，核心思路：

1. 先排序
2. 两层循环固定前两个数
3. 内层使用双指针寻找后两个数

5.2 剪枝优化的艺术

python复制def fourSum(nums, target):
    nums.sort()
    n = len(nums)
    result = []
    
    for i in range(n - 3):
        # 一级剪枝
        if nums[i] > target and nums[i] > 0 and target > 0:
            break
        if i > 0 and nums[i] == nums[i-1]:
            continue
            
        for j in range(i + 1, n - 2):
            # 二级剪枝
            if nums[i] + nums[j] > target and target > 0:
                break
            if j > i + 1 and nums[j] == nums[j-1]:
                continue
                
            left, right = j + 1, n - 1
            while left < right:
                total = nums[i] + nums[j] + nums[left] + nums[right]
                if total == target:
                    result.append([nums[i], nums[j], nums[left], nums[right]])
                    # 内层去重
                    while left < right and nums[left] == nums[left+1]:
                        left += 1
                    while left < right and nums[right] == nums[right-1]:
                        right -= 1
                    left += 1
                    right -= 1
                elif total < target:
                    left += 1
                else:
                    right -= 1
    return result

5.3 注意事项与常见错误

1. 剪枝条件要谨慎：只有当所有数都为正且当前和已大于目标时才可剪枝
2. 去重逻辑要一致：外层和内层都要正确处理相同元素
3. 整数溢出：对大数相加要考虑使用长整型

6. 哈希表与双指针的选择策略

经过这四道题目的训练，我们可以总结出以下选择策略：

1. 使用哈希表的场景：

   • 需要快速查找元素或统计频率
   • 问题可以转化为两数之和的变种
   • 不要求结果去重或去重简单

2. 使用双指针的场景：

   • 数组已排序或可以排序
   • 需要多指针协同工作
   • 结果需要严格去重
   • 可以利用有序性进行剪枝

在实际面试中，建议先分析问题特点，再选择合适的方法。有时候可以先提出哈希解法，再优化为双指针解法，展示思维过程。