Day15（哈希表 end）

于 2025-02-02 21:17:29 发布
阅读量885 收藏 15
点赞数 14
分类专栏： 代码随想录 文章标签： 算法 leetcode 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Glorious01/article/details/145422747
版权

💫脚踏实地，努力学习。(ง •_•)ง

📆学习日期：2025年2月2日13:55:37

💻学习内容：四数相加II | 赎金信 | 三数之和 | 四数之和

⏲️学习时长：5h30min

练习题目1-四数相加II
题目描述

中等

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

提示：

  • n == nums1.length
  • n == nums2.length
  • n == nums3.length
  • n == nums4.length
  • 1 <= n <= 200
  • -228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228
解题思路

map解题思路：

  1. 为什么想到要用哈希法解决：需要查询一个元素是否出现过
  2. 为什么要用map：需要保存两种数值，需要map的键值对来保存（key，value）
  3. 确定 key 是什么，value 是什么
  • 整体思路&&注意事项
  1. 比 ‘四数之和’简单，不需要考虑去重
  2. 需求：返回满足数相加的组合数
  3. 使用 map 进行解题， key存放数组元素之和a+b，value存放该结果的次数（表示共有几种a+b的结果）
  4. 4个数组两两分组，先遍历前两个数组，将加和结果存为 map ，将再遍历后两个数组进行查询，寻找满足条件的 map 成员
  • 整体时间复杂度n^2+n^2还是n^2，如果是1/3分组，则时间复杂度是n^2+n^2
  1. 查询到 map 中存在目标值，则count+=value，而不是count++
  • 代码实现
  1. 使用unordered_map

Bug

无o(*￣▽￣*)o

///2025年2月2日14:41:11
class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> map;key:a+b的数值，value:a+b数值出现的次数
        int count=0;
        int temp;

        for(int i=0;i<nums1.size();i++){//遍历数组1,2  存放加和结果与次数
            for(int j=0;j<nums2.size();j++){
                map[nums1[i]+nums2[j]]++;//根据[]进行单个插入，与insert不同
            }
        }

        for(int i=0;i<nums3.size();i++){//遍历数组3,4  寻找目标
            for(int j=0;j<nums4.size();j++){
                temp=0-(nums3[i]+nums4[j]);//目标值
                auto iter=map.find(temp);//在map中查找
                if(iter!=map.end()){//找到了
                    count+=iter->second;//count+=map[temp];//也可
                }

            }
        }

        return count;//返回组合结果数

    }
};

c++的STL简洁写法：

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;
    }
};
练习题目2-赎金信
题目描述

简单

给你两个字符串：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

提示：

  • 1 <= ransomNote.length, magazine.length <= 105
  • ransomNote 和 magazine 由小写英文字母组成

解题思路
  • 整体思路&&注意事项
  1. 只有小写字母，那可以采用空间换取时间的哈希策略，用一个长度为26的数组来记录magazine里字母出现的次数。
  2. 与算法学习Day11-有效的字母异位词 感觉很类似啊.... 用数组解决
  3. 字母不能重复使用
  • 代码实现
  1. 利用数组record统计magazine字符串出现的字母次数
  2. 遍历ransomNote，在record中查找是否有相应的字母，若至少不存在一个字母，则不能构成

Bug

无

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26];//数组下标为字母，存放其出现的次数
        for(int i=0;i<magazine.size();i++){//统计magazine中的字母
            record[magazine[i]-'a']++;//记录
        }

        for(int i=0;i<ransomNote.size();i++){//注意：magazine中的字母不能重复使用
            if(record[ransomNote[i]-'a']!=0){
                record[ransomNote[i]-'a']--;//使用1个，去掉一个
            }
            else return false;//若没有此字母，则返回false 
        }


        return true;
        
    }
};
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;
    }
};
  1. 增加判断条件：若magazine长度小于ransomNote，则一定无法构成
if (ransomNote.size() > magazine.size()) {
            return false;
        }
  1. s.size()与s.length()的区别：
  • 在字符串中s.size()与s.length()等价 字符串|string
  • length()只能获取字符串的长度，size()还可以获取vector容器的长度

C++基础用法——size()、length()-优快云博客

  1. record[ransomNote[j]-'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;
            }
        }
练习题目3-三数之和
题目描述

中等

给你一个整数数组 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 。

提示：

  • 3 <= nums.length <= 3000
  • -105 <= nums[i] <= 105
解题思路
  • 整体思路&&注意事项
  1. 此题与两数之和类似，但解题使用哈希法会比较复杂 算法学习Day14-两数之和
  2. 三元组需要去重，细节比较多，不建议使用哈希法
  3. 使用双指针法，需要先对数组进行排序，注意去重

  1. 代码大体思路（未包含去重）：
  • 对数组进行从小到大的排序
  • 外层 for 循环固定以nums[i]开头
  • 初始left指针指向下一个元素
  • 初始right指向最后一个元素
    • 内循环通过left和right指针的左右移动，寻找满足条件的三元组，直到left与right相遇，表明本次循环结束，开始进入下一个nums[i]
  • 将满足条件的(nums[i],nums[left],nums[right])存入二维数组result
  • 代码实现
  1. 对数组nums进行排序，sort(nums);//从小到大
  2. 遍历数组nums
  3. nums[i]去重：以此nums[i]开头进行收集三元组不要重复
  • if(i>0&&nums[i]==nums[i-1]) continue;//跳过这个重复的nums[i]，因为之前已经收集过以此nums[i]开头的三元组
  1. left与right的移动：
  • while(right>left)
  • 在排序数组的基础之上，三数之和＞0，则right--，三数之和<0，则left++
  • 将满足条件的(nums[i],nums[left],nums[right])存入二维数组result
  1. left与right的去重：例如数组[-1,-1,-1,0,1,1,1]，只需要一个(-1,0,1)
  2. 去重逻辑：至少收获1个结果，再去重
  3. 边界条件：
left++;//找到答案，两个指针同时收缩，才能使得left>right,结束循环
right--;//这两步没有写，导致死循环

Bug

  1. 边界条件判断没写，导致while死循环
//2025年2月2日17:32:00
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        //vector<vector<int>> result(nums.size(),vector<int>(3,0));//存放结果的二维数组,初始化
        vector<vector<int>> result;//不需要初始化,vector是一个可变长度的数组（?）

        for(int i=0;i<nums.size();i++){
            if(nums[i]>0) {
                return result;}//没有符合条件的3元组.直接返回最初的 空result

            if(i>0&&nums[i]==nums[i-1]) {
                continue;//a去重
            }

            int left=i+1;
            int right=nums.size()-1;

            while(right>left){
                if(nums[i]+nums[left]+nums[right]<0) left++;
                else if(nums[i]+nums[left]+nums[right]>0) right--;
                else {
                    vector<int> row={nums[i],nums[left],nums[right]};
                    result.push_back(row);

                    while(right>left&&nums[left]==nums[left+1]) left++;//找到一组答案，对b，c进行去重
                    while(right>left&&nums[right]==nums[right-1]) right--;

                    //这种写法是错误的，没有right>left 的条件判断将报错
                    // while(nums[left]==nums[left+1]) left++;//找到一组答案，对b，c进行去重
                    // while(nums[right]==nums[right-1]) right--;//

                    left++;//找到答案，两个指针同时收缩，才能使得left>right,结束循环
                    right--;//这两步没有写，导致死循环
                }

                
            }
        }
        return result;
    }
};
练习题目4-四数之和
题目描述

中等 18. 四数之和 - 力扣（LeetCode）

给你一个由 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]]

提示：

  • 1 <= nums.length <= 200
  • -109 <= nums[i] <= 109
  • -109 <= target <= 109
解题思路
  • 整体思路&&注意事项
  1. 延续三数之和的思路（双指针）
  • 在原有的循环之外，再加一层for循环 nums[k]
  1. 外层k循环：
    1. 细节：剪枝与去重
    • 例如三数之和中的 if(nums[i]>0) return result;//这就叫‘剪枝’
    • 本题不能使用剪枝if(nums[k]>target) return result;，因为加和结果是target，不是0，结果可能是正数也可能是负数。
    • 正确剪枝：if(nums[k]>target && nums[k]>0 ) break 待思考
    • 去重：if(k>0 && nums[k]==nums[k-1]) continue;
  1. 内层i循环：
    1. (二级)剪枝：if(nums[k]+nums[i]>target && nums[k]+nums[i]>0) break;
    2. (二级)去重：if(i>k+1 && nums[i]==nums[i-1])
  1. 最内层while循环：移动left/right指针
  • 与三数之和内容相似。
  • 代码实现

Bug

报错原因：int类型无法存放这么大的数据，改成long型

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;

        for(int k=0;k<nums.size();k++){
            if(nums[k]>target && nums[k]>=0) break;//剪枝
            if(k>0 && nums[k]==nums[k-1]) continue;//去重

            for(int i=k+1;i<nums.size();i++){
                if(nums[k]+nums[i]>target && nums[k]+nums[i]>=0 ) break;//剪枝
                if(i>k+1 && nums[i]==nums[i-1]) continue;//去重

                int left=i+1;
                int right=nums.size()-1;
                
                while(right>left){
                    if((long)nums[k]+nums[i]+nums[left]+nums[right]<target) left++;
                    else if((long)nums[k]+nums[i]+nums[left]+nums[right]>target) right--;
                    else{
                        result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
                        while(right>left && nums[left]==nums[left+1]) left++;//去重
                        while(right>left && nums[right]==nums[right-1]) right--;

                        //找到答案，双指针同时收缩
                        left++;
                        right--;
                    }
                }

            }

        }
        return result;
        
    }
};
学习总结

map解题思路：

  1. 为什么想到要用哈希法解决：需要查询一个元素是否出现过
  2. 为什么要用map：需要保存两种数值，需要map的键值对来保存（key，value）
  3. 确定 key 是什么，value 是什么

vector容器的使用 数组 | vector 待整理

  1. 定义
  2. 初始化
  • 什么是初始化
  • 什么时候需要初始化
  1. 添加元素 ： push_back()/insert()
  2. 排序
相关题目

四数之和

691. 贴纸拼词1160. 拼写单词

两数之和 简单

最接近的三数之和 中等

四数之和 中等

较小的三数之和 中等

等差三元组的数目 简单

元素和最小的山形三元组 I 简单

元素和最小的山形三元组 II 中等

两数之和 简单

三数之和 中等

四数相加 II 中等

统计特殊四元组 简单

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值