哈希表算法实战：从四数之和到字符统计

1. 哈希表算法精讲：从四数之和到赎金信的全方位解析

哈希表作为算法面试中的常客，其高效查找特性使其成为解决各类统计、查找问题的利器。今天我将结合LeetCode经典题目，深入剖析哈希表在不同场景下的应用技巧，并分享我在刷题过程中总结的实战经验。

1.1 四数相加II的哈希分治策略

454题四数相加II是展示哈希表威力的典型案例。题目要求统计四个数组中满足a+b+c+d=0的元组数量，直接暴力枚举时间复杂度高达O(n⁴)，显然不可行。

核心解法：采用分治思想，将问题拆解为两个两数之和问题：

1. 先计算nums1和nums2所有元素和，存入哈希表记录各和出现次数
2. 再计算nums3和nums4元素和的相反数，在哈希表中查找匹配

cpp复制int fourSumCount(vector<int>& nums1, vector<int>& nums2, 
                vector<int>& nums3, vector<int>& nums4) {
    unordered_map<int,int> sumMap;
    int count = 0;
    // 构建nums1+nums2的和频次表
    for(int a : nums1)
        for(int b : nums2)
            sumMap[a+b]++;
    
    // 查找nums3+nums4和的相反数
    for(int c : nums3)
        for(int d : nums4)
            if(sumMap.count(-c-d))
                count += sumMap[-c-d];
    
    return count;
}

复杂度分析：

• 时间复杂度：O(n²) 两次双重循环
• 空间复杂度：O(n²) 最坏情况下所有和都不相同

关键技巧：当遇到多变量组合问题时，考虑能否通过分组降低维度。哈希表在此充当了高效的"记忆体"，存储中间结果避免重复计算。

1.2 赎金信的字符统计艺术

383题赎金信要求判断杂志字符能否组成赎金信，是哈希表基础应用的典型场景。

解法对比：

1. 哈希表法：通用但需要处理哈希冲突
2. 数组法：针对小写字母场景更高效

cpp复制bool canConstruct(string ransomNote, string magazine) {
    int charCount[26] = {0};
    // 统计杂志字符库存
    for(char c : magazine)
        charCount[c-'a']++;
    
    // 检查赎金信字符消耗
    for(char c : ransomNote)
        if(--charCount[c-'a'] < 0)
            return false;
    
    return true;
}

性能优势：

• 数组访问O(1)时间复杂度
• 固定26长度数组，空间效率极高
• 避免哈希表扩容等额外开销

实战经验：当数据范围明确且有限时（如字母、0-9数字等），优先考虑数组替代哈希表，性能通常能提升20%-30%。

2. 双指针与哈希的默契配合

2.1 三数之和的去重艺术

15题三数之和是面试最高频题目之一，其解法展示了双指针与哈希表的取舍智慧。

为什么不用哈希表？

• 去重困难：哈希表难以处理如[-1,0,1]和[0,-1,1]这类顺序不同但元素相同的重复情况
• 代码复杂：需要额外处理各种边界条件

双指针解法要点：

1. 排序预处理：O(nlogn)
2. 固定一个数后转化为两数之和问题
3. 双指针从两端向中间扫描
4. 三重去重机制确保结果唯一

cpp复制vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> res;
    
    for(int i = 0; i < nums.size(); i++) {
        // 剪枝优化
        if(nums[i] > 0) break;
        // i去重
        if(i > 0 && nums[i] == nums[i-1]) continue;
        
        int left = i+1, right = nums.size()-1;
        while(left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if(sum < 0) left++;
            else if(sum > 0) right--;
            else {
                res.push_back({nums[i], nums[left], nums[right]});
                // 左右指针去重
                while(left < right && nums[left] == nums[left+1]) left++;
                while(left < right && nums[right] == nums[right-1]) right--;
                left++; right--;
            }
        }
    }
    return res;
}

复杂度对比：

2.2 四数之和的通用解法

18题四数之和将问题维度再次提升，但其核心思路与三数之和一脉相承。

解法框架：

1. 排序预处理
2. 双层循环固定前两个数
3. 双指针寻找后两个数
4. 多重剪枝和去重优化

cpp复制vector<vector<int>> fourSum(vector<int>& nums, int target) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> res;
    int n = nums.size();
    
    for(int i = 0; i < n; i++) {
        // 一级剪枝
        if(nums[i] > target && target >= 0) break;
        // i去重
        if(i > 0 && nums[i] == nums[i-1]) continue;
        
        for(int j = i+1; j < n; j++) {
            // 二级剪枝
            if(nums[i]+nums[j] > target && target >= 0) break;
            // j去重
            if(j > i+1 && nums[j] == nums[j-1]) continue;
            
            int left = j+1, right = n-1;
            while(left < right) {
                // 防止整型溢出
                long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
                if(sum < target) left++;
                else if(sum > target) right--;
                else {
                    res.push_back({nums[i],nums[j],nums[left],nums[right]});
                    // 双指针去重
                    while(left < right && nums[left] == nums[left+1]) left++;
                    while(left < right && nums[right] == nums[right-1]) right--;
                    left++; right--;
                }
            }
        }
    }
    return res;
}

关键细节：

1. 整型溢出处理：四个int相加可能超出INT_MAX，需要转为long
2. 剪枝优化：当nums[i] > target且target非负时提前终止
3. 去重逻辑：确保i、j和双指针三个维度的去重

3. 哈希表实战经验总结

3.1 数据结构选型指南

根据问题特点选择最优哈希结构：

3.2 性能优化技巧

1. 预分配空间：对于已知规模的哈希表，使用reserve预先分配足够空间，避免rehash

cpp复制unordered_map<int,int> mp;
mp.reserve(n*n); // 四数相加II中的优化

2. 查找优化：优先使用count()而非find()检查存在性，代码更简洁

cpp复制// 更优写法
if(mp.count(key)) {...}

// 而非
if(mp.find(key) != mp.end()) {...}

3. 批量操作：利用emplace_hint在已知插入位置时提高插入效率

3.3 常见错误排查

1. 哈希碰撞：当数据量较大时，考虑自定义哈希函数

cpp复制struct custom_hash {
    size_t operator()(int x) const {
        x = ((x >> 16) ^ x) * 0x45d9f3b;
        return x;
    }
};
unordered_map<int, int, custom_hash> safe_map;

2. 迭代器失效：在遍历过程中修改哈希表会导致未定义行为

3. 默认值陷阱：访问不存在的键时会自动插入，必要时使用at()方法

cpp复制map<int,int> mp;
cout << mp[1]; // 自动插入{1,0}
cout << mp.at(2); // 抛出异常

哈希表作为算法工程师的必备工具，其灵活性和高效性在各类场景中发挥着关键作用。通过合理选择数据结构、优化实现细节，并理解各种变种问题的解法思路，我们能够应对日益复杂的算法挑战。