算法学习Day7 | Chapter3哈希表

最新推荐文章于 2024-11-04 13:07:19 发布

sxz_dududu

最新推荐文章于 2024-11-04 13:07:19 发布

阅读量92

点赞数 1

分类专栏：算法学习文章标签：学习散列表 leetcode c++ 数据结构 Powered by 金山文档

本文链接：https://blog.csdn.net/sxz_dududu/article/details/129151071

版权

算法学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章详细介绍了如何使用哈希表和双指针法解决四数相加II、赎金信、三数之和的问题。针对四数相加II，通过两两组合存储数值及其频率；赎金信问题中，利用数组检查ransomNote是否能由magazine构建；三数之和问题采用排序和双指针去除重复项找到所有三元组。

摘要由CSDN通过智能技术生成

3.6 四数相加II

链接：文章；视频；454.四数相加II

需要存储数值和其出现的次数，所以使用map；而且，不用考虑有重复的四个元素相加等于0的情况。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;
        int count = 0;
        for (int a : nums1) { // nums1、nums2一组
            for (int b : nums2) {
                map[a + b]++;
            }
        }
        for (int c : nums3) { // nums3、nums4一组
            for (int d : nums4) {
                int target = 0 - (c + d);
                if (map.find(target) != map.end()) {
                    count += map[target];
                }
            }
        }
        return count;
    }
};

3.7 赎金信

链接：文章；383.赎金信

不需要给出满足条件个数，且只有小写字母，用数组更合适。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
    // magazine要包含ransomNote
        int num[26] = {0};
        for (int i = 0; i < magazine.size(); i++) {
            num[magazine[i] - 'a']++;
        }
        for (int j = 0; j < ransomNote.size(); j++) {
            num[ransomNote[j] - 'a']--;
            if (num[ransomNote[j] - 'a'] < 0) { // 一定得大于等于0
                return false;
            }
        }
        return true;
    }
};

3.8 三数之和

链接：文章；视频；15.三数之和

双指针法：（去重逻辑很重要，每个元素都要去重奥）

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result; // 定义存放三元组的二维数组
        sort(nums.begin(), nums.end()); // 排序
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.size(); i++) {
            // 剪枝操作
            if (nums[i] > 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) {
            // 如何移动左右指针
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                } else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                } else {
                    result.push_back(vector<int>({nums[i], nums[left], nums[right]}));
                    // 在找到第一个三元组后，对b和c进行去重
                    while (left < right && nums[right] == nums[right - 1]) { 
                    // 这里的left和right为什么还要加呢？
                        right--;
                    }
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    //找到答案，指针回缩
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

3.9 四数之和

链接：文章；视频；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) { // 剪枝k
            // nums[k] >= 0可换为target > 0
                break;
            }
            if (k > 0 && nums[k] == nums[k - 1]) { // 去重k
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) { // 剪枝i
                    break;
                }
                if (i > k + 1 && nums[i] == nums[i - 1]) { // 去重i
                    continue; 
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (left < right) {
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    } else if ((long) nums[k] + nums[i] + nums[left] + nums[right] < target) { // 这里为什么用long？
                        left++;
                    } else {
                        result.push_back(vector<int>({nums[k], nums[i], nums[left], nums[right]}));
                        while (left < right && nums[left] == nums[left + 1]){ // 去重left
                            left++;
                        }
                        while (left < right && nums[right] == nums[right - 1]){ // 去重right
                            right--;
                        }
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};