跟着代码随想录刷题第十一天(2023.4.23) -- 哈希表 5~6

一、Leetcode第454题：四数相加||

 思路：四个数组中各拿出一个元素相加，要求和等于 0 ，统计和为0 出现的次数。这里面出现了三个 变量， 数组元素 、相加和、 和为0次数，应该想到把相加和作为 key， 和为0次数作为 value，四个数组，划分前两组中元素的和作为map容器中的元素，后两个用作 差值的查找。

随想录给出的解题步骤如下:

 代码：
 

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        std::unordered_map <int, int> map;
        int count = 0;
        for(int ii = 0; ii < nums1.size(); ii++) {
            for(int jj = 0; jj < nums2.size();jj++) {
                int sum = nums1[ii] + nums2[jj];
                auto iter = map.find(sum);
                if(iter == map.end()) map.insert(pair<int, int>(sum, 1));
                else iter->second += 1;
            }
        }
        for(int ii = 0; ii < nums3.size(); ii++) {
            for(int jj = 0; jj < nums4.size(); jj++) {
                int sum = nums3[ii] + nums4[jj];
                auto iter = map.find(0 - sum);
                if( iter != map.end() )
                    count += iter->second;
            }
        }
        return count;
    }
};

基于范围for循环的代码（真的好简洁！）：

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int> umap; //key:a+b的数值，value:a+b数值出现的次数
        // 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
        for (int a : A) {
            for (int b : B) {
                umap[a + b]++;
            }
        }
        int count = 0; // 统计a+b+c+d = 0 出现的次数
        // 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
        for (int c : C) {
            for (int d : D) {
                if (umap.find(0 - (c + d)) != umap.end()) {
                    count += umap[0 - (c + d)];
                }
            }
        }
        return count;
    }
};

二、Leetcode第383题：赎金信

 思路：想到把magazine中的每个元素都存入哈希表中，元素值为key，每个元素出现的次数为val，再用ransomNote去哈希表中查找，每个元素查找到一次，对应key就减一，若有减到0的就返回false。代码如下：
 

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map <int, int> umap;
        for(int ii = 0; ii < magazine.size(); ii++){
            auto iter = umap.find(magazine[ii]);
            if(iter == umap.end()) umap.insert(pair<int, int> (magazine[ii], 1));
            else iter->second +=1;
        }
        for(int ii = 0; ii < ransomNote.size(); ii++) {
            auto iter = umap.find(ransomNote[ii]);
            if(iter == umap.end()) return false;
            else if(iter->second == 1) umap.erase(iter);
            else iter->second -= 1;
        }
        return true;
    }
};

又写了一个for循环版本：

// 范围for循环版
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        std::unordered_map <int, int> umap;
        for(int a : magazine) {
            umap[a]++;
        }
        for(int b : ransomNote){
            if(umap.find(b) == umap.end() || umap[b] == 0) return false;
            else umap[b]--;
        }
        return true;
    }
};

看随想录说用哈希表比较费时，用数组比较好，测试了一下确实是这样，数组写的代码如下：

// 数组法
// 时间复杂度: O(n)
// 空间复杂度：O(1)
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++) {
            // 通过recode数据记录 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;
    }
};