代码随想录算法训练营第7天 |第三章哈希表part02

猪肘子在煮

已于 2024-02-20 21:49:39 修改

阅读量506

点赞数 12

分类专栏： Leetcode 文章标签： leetcode

于 2023-12-05 21:44:56 首次发布

本文链接：https://blog.csdn.net/qq_43750923/article/details/134810234

版权

Leetcode 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

学习目标：

454.四数相加II
383. 赎金信
15. 三数之和
18. 四数之和

学习内容：

454.四数相加II

整体思路：分为两组，前一组相加后，所需要的数在后两组相加的结果中寻找。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap; //key:a+b的数值，value:a+b数值出现的次数
        //nums1 nums2 作为一个小组
        for(int i = 0; i<nums1.size();i++)
            for(int j = 0;j<nums2.size();j++)
            {
                umap[nums1[i]+nums2[j]]++;
            }
        //nums3 nums4 作为一个小组
        int count=0; //记录返回结果的个数
        for(int i = 0; i<nums3.size();i++)
            for(int j = 0;j<nums4.size();j++)
            {
                count+=umap[(0-nums3[i]-nums4[j])];
            }
        return count;

    }
};

unordered_map是C++ STL库中的一个容器，它提供了基于哈希表的键值对映射，即可以用一个键来查找对应的值，底层数据结构是哈希表。使用unordered_map需要包含头文件<unordered_map>，下面是一个简单的例子：

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    unordered_map<string, int> umap; // 创建一个 unordered_map 对象
    umap["apple"] = 1; // 插入一个键为 "apple"，值为 1 的元素
    umap["banana"] = 2; // 插入一个键为 "banana"，值为 2 的元素
    umap["orange"] = 3; // 插入一个键为 "orange"，值为 3 的元素

    // 遍历 unordered_map 中的元素
    for (auto it : umap) {
        cout << it.first << " : " << it.second << endl;
    }

    // 查找元素
    if (umap.find("apple") != umap.end()) {
        cout << "apple found!" << endl;
    } else {
        cout << "apple not found!" << endl;
    }
    return 0;
}

输出结果为：

orange : 3
banana : 2
apple : 1
apple found!

在这个例子中，我们首先创建了一个unordered_map对象umap，它的键是字符串类型，值是整型。然后，我们使用成员函数[]，将三个键值对插入到umap中。接着，我们使用一个for循环遍历umap中的所有键值对，并输出它们的键和值。最后，我们使用find函数查找特定键的元素是否在umap中存在。unordered_map是C++ STL库中的一个容器，它提供了基于哈希表的键值对映射，即可以用一个键来查找对应的值，底层数据结构是哈希表。使用unordered_map需要包含头文件<unordered_map>，下面是一个简单的例子：

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    unordered_map<string, int> umap; // 创建一个 unordered_map 对象
    umap["apple"] = 1; // 插入一个键为 "apple"，值为 1 的元素
    umap["banana"] = 2; // 插入一个键为 "banana"，值为 2 的元素
    umap["orange"] = 3; // 插入一个键为 "orange"，值为 3 的元素

    // 遍历 unordered_map 中的元素
    for (auto it : umap) {
        cout << it.first << " : " << it.second << endl;
    }

    // 查找元素
    if (umap.find("apple") != umap.end()) {
        cout << "apple found!" << endl;
    } else {
        cout << "apple not found!" << endl;
    }
    return 0;
}

输出结果为：

orange : 3
banana : 2
apple : 1
apple found!

unordered_map可以用++来增加value值吗
可以，使用unordered_map[key]++可以增加对应key的value值，如果key不存在，则会在map中创建一个新的key，其对应的value值为0，然后执行自增操作。可以，使用unordered_map[key]++可以增加对应key的value值，如果key不存在，则会在map中创建一个新的key，其对应的value值为0，然后执行自增操作。

错误以及注意事项

这里我首先的想法是，第二个小组里，每次查找有没有对应所需要的need，如果有就–，最后找umap里数值为0的个数，但是这样的情况没有考虑到一二两组的排列组合，同时也强调了错误的一一对应。
后来我重新看了看正确的代码，为什么这个代码里没有类似于乘法的排列组合呢？因为在第二个组的循环里，每个都遍历了一遍，遇到相同的第二小组nums3+nums4，还是会相对应的增加count。

class Solution {
public:
        //方法2
        int k = nums.size()-1; //定义一个指针从数组最后一个位置放最大值
        vector<int> result(nums.size(),0); //注意新建数组的写法
        for(int i = 0, j = nums.size()-1 ; i <= j;)
        {
            if(nums[i]*nums[i] < nums[j]*nums[j]){
                result[k] = nums[j]*nums[j];
                k--;
                j--;
            }
            else{
                result[k] = nums[i]*nums[i];
                k--;
                i++;
            }
        }
        return result;

    }
};

383. 赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        //用一个数组来存储
        vector<int> tmp(26,0);
        for(int i = 0;i<magazine.size();i++){
            tmp[magazine[i]-'a']++;
        }
        for(int i = 0;i<ransomNote.size();i++){
            tmp[ransomNote[i]-'a']--;
            if(tmp[ransomNote[i]-'a']<0)
                return false;
        }
        return true;

    }
};

错误以及注意事项

忘记减去-‘a’了！！相对相对大小！切记切记！！

15. 三数之和

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){
                // 如果第一个数都大于0，那么无论后面如何凑都不可能变成0
                return result;
            }
            //去重a
            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{
                    //等于0了，将对应的数插入result中
                    result.push_back({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靠近彼此
                    left++;
                    right--;

                }
            }
        }
        return result;

    }
};

错误以及注意事项

这里要考虑a,b,c 三个的去重，a是从头遍历到尾，所以重复了的话，就直接跳过去。但是考虑一个问题是，检查是否重复的时候是比较前一个还是后一个。我们就把三元组中出现重复元素的情况直接pass掉了。例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断下一个也是-1，那这组数据就pass了。是不能有重复的三元组，但三元组内的元素是可以重复的！

if (nums[i] == nums[i + 1]) { // 错误的去重操作
    continue;
}

if (i > 0 && nums[i] == nums[i - 1]) {// 正确的去重操作
    continue;
}

18. 四数之和

//正确答案
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            // 剪枝处理
            if (nums[k] > target && nums[k] >= 0) {
            	break; // 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // 2级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }

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

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

            }
        }
        return result;
    }
};

错误以及注意事项

//第一次错误答案
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        for(int k = 0;k<nums.size();k++)
        {
            if(nums[k]>target) //如果第一个就大于target，则后面的怎么相加都无法降下来
            {
                break; 
            }
            //去重a
            if(k>0 && nums[k]==nums[k-1]){
                continue;
            }
            for(int i = k+1;i<nums.size();i++)
            {
                //去重b
                if(nums[i]==nums[i-1]){
                    continue;
                }
                int left = i+1;
                int right = nums.size()-1;
                while(left<right){
                    int sum = nums[k]+nums[i]+nums[left]+nums[right];
                    if(left<right && sum<target){
                        left++;
                    }
                    else if(left<right && sum>target){
                        right--;
                    }
                    else{
                        result.push_back({nums[k],nums[i],nums[left],nums[right]});
                        //去重c,d
                        if(nums[left]==nums[left+1]){
                            left++;
                        }
                        if(nums[right]==nums[right-1]){
                            right--;
                        }
                        //结束一次搜寻后left right动动
                        left++;
                        right++;
                    }
                }
            }
        }
        return result;

    }
};

剪枝的时候没有考虑到负数+负数会变得更小的情况
去重b的时候没有考虑-1越界的问题
一直281/294 passed 看的我脑袋都是大的。

学习时间：

2023.12.5 15:35-21:44

啊做的想死。有一种大家都在hard难度我才刚刚开始玩泥巴的感觉！！

猪肘子在煮

关注

12
点赞
踩
11

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营第7天 |第三章哈希表part02

在这个例子中，我们首先创建了一个unordered_map对象umap，它的键是字符串类型，值是整型。unordered_map是C++ STL库中的一个容器，它提供了基于哈希表的键值对映射，即可以用一个键来查找对应的值，底层数据结构是哈希表。可以增加对应key的value值，如果key不存在，则会在map中创建一个新的key，其对应的value值为0，然后执行自增操作。可以增加对应key的value值，如果key不存在，则会在map中创建一个新的key，其对应的value值为0，然后执行自增操作。
复制链接

扫一扫