训练营day07 哈希表 | 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和 、哈希表总结

454.四数相加II

思路

1-定义map，key存放a+b的值，value存放a+b出现的次数

2-遍历c, d，在map中寻找0-(c+d)，找到后便在count中加上map的value值

3-返回count

代码

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;
        // 不要忘了加数据类型 int 这种遍历方法是C++11中特有，专门为STL设计
        for(int a:nums1){
            for(int b:nums2){
                map[a+b]++;
            }
        }
        int count = 0;
        for(int c:nums3){
            for(int d:nums4){
                if(map.find(0-(c+d)) != map.end()){
                    count += map[0-(c+d)];
                }
            }
        }
        return count;
    }
};

小结

这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不需要去重，所以相对于题目18. 四数之和，题目15.三数之和，还是简单了不少！

383. 赎金信

思路

1-定义数组，存储magazine中各字母出现次数

2-数组中查找ransomNote中每个字母对应的值，-1

3-遍历数组，如果有元素小于0则失败

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        for(int m:magazine){
            record[m - 'a']++;
        }
        for(int n:ransomNote){
            record[n - 'a']--;
            if(record[n - 'a'] < 0){
                return false;
            }
        }
        return true;

    }
};

小结

如果用数组和map都能解决问题的话，要优先考虑用数组解决，因为map的空间消耗要比数组大。map要维护红黑树或哈希表，而且还要做哈希函数，是费时的。数据量大就会体现出差别。

对vector长度可用.size()表示，对array不能用.size()，可以用array::size()

15. 三数之和

思路

两数之和用哈希法，但如果三数之和用哈希法会比较麻烦（去重麻烦，去重细节太多），时间复杂度O(n^2)

双指针法更容易理解，因为没有要求返回下标，所以可以排序。

1-从小到大排序

2-遍历a的值，注意去重条件： nums[i]==nums[i-1]时continue

3-双指针：左left(i+1)，右right，从两头向中间靠近

4-对同一个a来说，当三者之和>0时，right左移；当三者之和<0时，left右移；当等于0时，存到结果数组，再对b和c进行去重

代码

// 题目：使得a+b+c=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++){
            // 剪枝操作，说明也就遍历到最后一个负数，后面不用遍历了
            if(nums[i] > 0){
                break;
            }
            // 对a去重
            // if中i>0是为了防止i=0的情况
            if(i>0 && nums[i]==nums[i-1]){
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right){
                int sum = nums[i] + nums[left] + nums[right];
                if(sum > 0){
                    right--;
                }
                else if(sum < 0){
                    left++;
                }
                else{
                    // 向二维数组result中放一维数组
                    result.push_back(vector<int> {nums[i], nums[left], nums[right]});
                    // 对b, c去重，放在这里是因为保证有一组解再去掉重复的
                    while(left < right && nums[left] == nums[left+1]){
                        left++;
                    }
                    while(left < right && nums[right] == nums[right-1]){
                        right--;
                    } 
                    left++;
                    right--;
                }  
            }
        }
        return result;
    }
};

注意剪枝和去重操作

18. 四数之和

思路

整体思路是在三数之和的基础上外面套一个循环，但重点是剪枝和去重的细节

因为前面三数之和是加起来等于0，所以nums[i]不能是正数，但这里如果target是负数，负数越加越小，所以不能说明nums[i]必须比target大或小，所以要再加个附加条件

注意一二级剪枝和去重

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(nums[i]>target && target>=0)
                break;
            // 一级去重
            if(i>0 && nums[i]==nums[i-1])
                continue;
            for(int j=i+1; j<nums.size(); j++){
                // 二级剪枝
                if(nums[i]+nums[j]>target && target>=0)
                    break;
                // 二级去重
                if(j>i+1 && nums[j] == nums[j-1])
                    continue;
                int left = j+1;
                int right = nums.size()-1;
                while(left < right){
                    // 因为测试中数太大，所以需要把int转换成long才能在相加时不溢出
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if(sum > target) right--;
                    else if(sum < target) left++;
                    else{
                        result.push_back(vector<int> {nums[i], nums[j], nums[left], nums[right]});
                        // 去重  这里加left<right是防止，本来满足条件却因为left一直往右或right一直往左而导致该情况没被记录
                        while(left<right && nums[left] == nums[left+1]) left++;
                        while(left<right && nums[right] == nums[right-1]) right--;
                        left++;
                        right--;
                    }
                } 
            }
        }
        return result;
    }
};

今日小结

使用哈希表hash就是牺牲空间换时间，工业开发中也是这样

三数之和、四数之和若利用哈希表，则去重会很麻烦，所以用双指针方法，四数之和及以上的问题都是在三数之和的双指针基础上向外套循环，只是要注意每一级剪枝和去重

四数相加问题因为问的是有几种相加的可能性，不用考虑去重，所以用哈希表map方法求解

赎金信问题因为是字符串，所以不用单独的key值，直接用数组下标即可，所以用数组哈希法方式，不需要用到map，节省空间、提高效率

哈希表总结

代码随想录

何时用哈希法？

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

何时用数组, set, map？

数组：在长度较为固定（如字符串最多对应26个字母），且哈希值分散较密集不会浪费太多空间时，使用数组简单高效。所以是非常适用于对字符串的处理

set：当长度不能固定时，或哈希值分布分散时，使用数组可能会占用太多存储空间，可用set

map：当需要存储key和value两个值时，不能使用set；当哈希值分布分散或者长度不能确定时，数组不合适；此时用map合适

set和map在C++中的三种结构？

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)