day7-哈希表算法题进阶

企鹅chi月饼

已于 2025-03-22 00:06:07 修改

阅读量922

点赞数 17

文章标签： 66天算法训练计划代码随想录哈希表 unordered_map unordered_set

于 2025-03-20 16:52:01 首次发布

本文链接：https://blog.youkuaiyun.com/cyz322649/article/details/146401181

版权

第454题.四数相加II

题目描述

题目链接：454. 四数相加 II - 力扣（LeetCode）

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

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

n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28

题目思路

首先看到这个题目的话，暴力的解法绝对是超时，虽然这里n<=200，但是时间复杂度为O(n^4),但是很显然是会超时的。

然后我看了一点录哥的思路，后面加上了自己的想法，可以对每两个数组进行合并，将和放置到unordered_map中，这样可以转化成leedcode第一题两数之和的大致思路。不了解leedcode两数之和这道题解法的可以看文章（建议先看懂两数之和这道题再来看四数相加这道题）：

day6-哈希表（unordered_set，unordered_map）算法题基础-优快云博客

详细思路

1.

计算nums1和nums2这两个数组中，所有元素组和 nums1[i] + nums2[j]。
将这个和作为键 (key) 存入 map1 中，并将该和出现的次数作为值 (value)。如果该和已经存在于 map1 中，则将其对应的频率加 1。
目的: unordered_map1 存储了 nums1 和 nums2 中所有可能的两数之和以及每个和出现的次数。

2.

同理计算nums3和nums4的所有元素组和，用unordered_map2存储了 nums3 和 nums4 中所有可能的两数之和以及每个和出现的次数。

3.

然后用迭代器来遍历其中的一个unordered_map，拿到的"两数和"为 it->first，我们需要在另一个unordered_map中来找到键为-it->first的键值对，这样可以找到凑成0的4数和。如果能找到的话，num+=it->second*map2[-it->first];

代码实现

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> map1;
        unordered_map<int,int> map2;

        for(int i=0; i<nums1.size(); i++){
            for(int j=0; j<nums2.size(); j++){
                map1[nums1[i]+nums2[j]]++;
            }
        }

        for(int i=0; i<nums3.size(); i++){
            for(int j=0; j<nums4.size(); j++){
                map2[nums3[i]+nums4[j]]++;
            }
        }

        int num=0;//统计四数和为0的组和数量
        for(auto it=map1.begin(); it!=map1.end(); it++){
            if(map2.count(-it->first)){
                num+=it->second*map2[-it->first];
            }

        }
        return num;
        }
};

代码优化

合并 map 的创建和遍历（稍微更紧凑，但可能牺牲一些可读性）：

1. 可以只使用一个 unordered_map。首先计算 nums1 和 nums2 中所有元素对的和，并存储它们的频率。（这点和我上面的做法一致）

2. 然后，遍历 nums3 和 nums4 中的所有元素对的和。对于每个和 sum34，检查 -sum34 是否存在于之前创建的 map 中。如果存在，则将它们的频率相乘并加到结果中。

（可以发现我们这里并没有创建一个 unordered_map来保存 nums3 和 nums4中所有元素对的和以及频率，这种方式的优点是只使用了一个哈希表，在内存使用上略有优势，此外时间上也略有优势。）

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> sum12_freq;
        for (int n1 : nums1) {
            for (int n2 : nums2) {
                sum12_freq[n1 + n2]++;
            }
        }

        int count = 0;
        for (int n3 : nums3) {
            for (int n4 : nums4) {
                int target = -(n3 + n4);
                if (sum12_freq.count(target)) {
                    count += sum12_freq[target];
                }
            }
        }
        return count;
    }
};

对于范围for的解释

代码优化部分，我们使用的是范围for来遍历数组和unordered_map，这样的话可读性更好，我们就不需要通过迭代器进行遍历了。范围for是c++11新特性。

我一般很少使用范围for，感觉使用范围for，与底层的细节理解有点脱离的感觉，不太习惯。

值拷贝：
- 默认情况下，基于范围的 for 循环会创建一个容器中每个元素的副本，并将其赋值给循环变量。
- 因此，在循环体中对循环变量的修改，实际上是修改了副本，而不是原始容器中的元素。
引用：
- 通过使用引用（&），你可以让循环变量直接指向原始容器中的元素，而不是副本。
- 这样，在循环体中对循环变量的修改，就会直接反映到原始容器中的元素上。

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 不使用引用，无法修改元素
    for (int element : vec) {
        element *= 2;
    }
    // 使用引用，可以修改元素
    for (int &element : vec) {
        element *= 2;
    }
}

由于其简洁性和安全性，基于范围的 for 循环通常是遍历容器或数组的首选方法。

383题赎金信

和leedcode242题目对比

题目链接：383. 赎金信 - 力扣（LeetCode）

这道题目和242.有效的字母异位词 (opens new window)很像，242.有效的字母异位词 (opens new window)相当于求字符串a 和字符串b 是否可以相互组成，而这道题目是求字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。

但是两个题目的思路都是一样的啦，最后可能检测的逻辑稍稍不同。

关于242题目的详细做题思路，在我的上一篇文章中有讲到，直接给出链接，不多详细赘述：

day6-哈希表（unordered_set，unordered_map）算法题基础-优快云博客

对于这个题来说我们依旧选择开一个26大小的数组来实现快速查找，如果说你想用unordered_map的话当然也可以，不过unordered_map要维护哈希表，设计到哈希函数，效率上肯定是不如直接用数组的。一般能用数组的话，我们尽量就不要使用unordered_map和unordered_set啦。

代码实现

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        //add
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        for (int i = 0; i < magazine.length(); i++) {
            // 通过record数据记录 magazine里各个字符出现次数
            record[magazine[i]-'a'] ++;
        }
        for (int j = 0; j < ransomNote.length(); j++) {
            // 遍历ransomNote，在record里对应的字符个数做--操作
            record[ransomNote[j]-'a']--;
            // 如果小于零说明ransomNote里出现的字符，magazine没有
            if(record[ransomNote[j]-'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};