C++ 哈希表入门：LeetCode经典问题解析2

C++ 哈希表入门：LeetCode经典问题解析2

在算法题中，哈希表与双指针是一对非常重要且实用的组合工具，特别是在处理高效查找与去重问题上有着极高的优势。在这篇博客中，我们将通过几个LeetCode经典问题的详细解析，来深入理解哈希表与双指针的应用。这几道题目涵盖了常见的数组查找、字符串匹配以及数值组合问题，能够帮助大家掌握相关的解题技巧，并将其运用到实际开发中。

首先，我们将从哈希表入手，分析 「四数相加II」 和 「赎金信」 的解题思路，如何高效记录和查找数据，通过哈希表的映射关系来减少复杂度。接着，我们会探讨 「三数之和」 和 「四数之和」 这类需要精确匹配目标值的组合问题，结合双指针策略的去重与优化，使得求解大规模数组的组合更加简单高效。

这些题目中所涉及的算法技巧，包括了：

1. 哈希表：利用哈希表来记录和查找数值组合，避免冗余计算。
2. 双指针：在有序数组上使用双指针，不仅可以节省时间，还能轻松处理重复数据。
3. 去重处理：针对重复元素的处理是组合问题中的一大难点，尤其在多数和问题中更为关键。

下面，我们将逐题展开，带大家深度理解每道题目的解题思路，逐步积累算法和数据结构的知识。

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

这个问题的核心思想是将问题分解成两个部分来处理。我们可以先将两个数组的元素和存入哈希表中，再用另两个数组的元素和去查找满足条件的元组。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int result = 0;
        unordered_map<int, int> map;

        // 统计 nums1 和 nums2 所有元素之和的出现次数
        for (int a : nums1) {
            for (int b : nums2) {
                map[a + b]++;
            }
        }

        // 遍历 nums3 和 nums4，将目标值的相反数查找是否存在于 map 中
        for (int c : nums3) {
            for (int d : nums4) {
                int target = -c - d;
                if (map.find(target) != map.end()) {
                    result += map[target];
                }
            }
        }
        
        return result;
    }
};

代码解析

1. 将 nums1 和 nums2 的所有元素和加入哈希表 ：对于每一对 (a, b)，我们将它们的和 a + b 作为键存入 map，值为该和出现的次数。
2. 查找满足条件的元组 ：对于 nums3 和 nums4 中的每一对 (c, d)，如果 -c - d 在 map 中存在，说明存在组合使得和为零。

通过这种方式，整个算法的时间复杂度从 O ( n 4 ) O(n^4) O(n4) 降至 O ( n 2 ) O(n^2) O(n2)，极大地优化了效率。

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

注：这道题不管每个字符的先后顺序和是否需要连续出现，所以很简单，之前这道最小覆盖子串难度更大，是哈希+双指针法，感兴趣的可以回顾一下双指针法从入门到精通-CSDN博客

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> map;
        
        // 统计 magazine 中每个字符的出现次数
        for (char c : magazine) {
            map[c]++;
        }

        // 检查 ransomNote 中的每个字符是否可以在 map 中找到足够的次数
        for (char c : ransomNote) {
            if (map[c] > 0) {
                map[c]--;
            } else {
                return false;
            }
        }
        
        return true;
    }
};

代码解析

1. 建立字符频率表 ：我们先遍历 magazine，记录每个字符的出现次数。
2. 匹配字符 ：遍历 ransomNote，检查字符是否在 map 中存在足够数量；如果不足，返回 false。

这道题的时间复杂度是 O ( n ) O(n) O(n)，非常高效。通过哈希表记录字符出现次数，这种方法不仅简单且符合直觉。

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

注：这道题主要考察的还是双指针，难点在于去重处理

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int i=0; i<nums.size();i++){
            int left=i+1, right=nums.size()-1;
            int target=-nums[i];
            if (i > 0 && nums[i] == nums[i - 1]) continue;//去除重复的nums[i]
            while(left<right){
                int sum=nums[left]+nums[right];
                if(sum<target){
                    left++;
                }else if(sum>target){
                    right--;
                }else{
                    result.push_back({nums[i], nums[left], nums[right]});
                    //去除重复的nums[left]
                    while(left<right && nums[left]==nums[left+1]) left++;
                    //去除重复的nums[right]
                    while(left<right && nums[right]==nums[right-1]) right--;
                    right--;//要同时收缩
                    left++;
                }
            }
        }
        return result;
    }
};

代码解析

1. 排序数组 ：先对 nums 进行排序。
2. 双指针查找 ：固定 nums[i] 后，用左右指针寻找两个数的和等于 -nums[i]。
3. 去重处理：跳过连续相同的元素以避免重复三元组。

这种方法将问题转化为两数之和的问题，并通过排序和双指针进行高效查找。

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复 的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> result;
        for(int i=0; i<nums.size(); i++){
            if(i>0&&nums[i]==nums[i-1]) {continue;}
            for(int j=i+1; j<nums.size(); j++){
               if(j>i+1 && nums[j]==nums[j-1]) {continue;}
               int left=j+1, right=nums.size()-1;
               while(left<right){
                  if((long)nums[i]+nums[j]+nums[left]+nums[right]>target) {right--;}
                  else if((long)nums[i]+nums[j]+nums[left]+nums[right]<target) {left++;}
                  else{result.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--;
                  right--;left++;}
                }
            }
        }
        return result;
    }
};

代码解析

1. 排序数组：对数组排序，便于使用双指针。
2. 嵌套双层循环 + 双指针：固定前两个数，通过双指针找到后两个数使得四数和等于目标值。
3. 去重处理：跳过重复的元素避免重复结果。

这些问题展示了哈希表、双指针和排序在 C++ 中解决数组问题的常见模式。通过优化复杂度，使用合适的数据结构，能有效提升算法效率，尤其适用于大规模数据的处理。