第三章哈希表part02

C1aySec

于 2024-06-13 16:20:06 发布

阅读量976

点赞数 9

分类专栏：代码随想录文章标签：散列表算法 leetcode

本文链接：https://blog.csdn.net/a781333978/article/details/139657532

版权

代码随想录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

四数相加II

题目描述

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入:

A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:

解释:

两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

解题思路

总体思路

首先选择合适的数据结构，通过分析题意我们可以将四个数组中分别取一个值累加为0这个条件转换为分别数组c和数组d中找到两个数值c，d，满足两数之和符合0-(a+b)，符合从XX中找到满足XX条件这一情况，因此可以选用哈希表进行解析，因为两数之和可能会出现相同的值，因此还需要一个位置来存放出现的次数，因此可以选用unordered_map
定义一个unordered_map，key用于存放两个数组中的元素累加和，value用于存放累加和出现的次数
首先遍历a，b数组，将累加和次数保存到umap中，然后遍历c，d数组，找到满足umap[0-(c+d)]的值，定义一个计数器加上umap[0-(c+d)]对应的value值
返回计数器的值即可

时空复杂度分析：

时间复杂度: O(n^2)
空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2

代码实现

测试地址：https://leetcode.cn/problems/4sum-ii/description/

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

赎金信

题目描述

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

解题思路

总体思路

通过分析题意可以得到因为magazines需要包含ransom中的所有字符，因此magazines的长度必定>=ransom，字符均为小写，且magazines中的字符不能重复使用，由于范围可控，因此可以使用数组进行解题
定义一个数组record，初始化为0，大小为26，用于存储magazines中出现的所有字符
判断magazines的长度是否大于ransom的长度，如果小于，直接返回false
遍历ransom字符串，找record数组中寻找所需字符是否足够充足，如果都能找到的话就返回true，否则返回false

时空分析：

时间复杂度: O(n)
空间复杂度: O(1)

代码实现

测试地址：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0}; //数组初始化为0
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        for (int i = 0; i < magazine.length(); i++) {
            // 通过record数据记录 magazine里各个字符出现次数
            record[magazine[i] - 'a']++;
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            // 遍历ransomNote，在record里对应的字符个数做--操作
            record[ransomNote[i] - 'a']--;
            // 如果小于零说明ransomNote里出现的字符，magazine不够用了
            if (record[ransomNote[i] - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

三数之和

题目描述

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

解题思路

双指针思路

总体思路

分析题意可知，我们需要同时对数组内的三个元素累加和进行判断，因此可以使用双指针思路，引入left和right指针，将数组进行排序后，将left指向i+1位置，right执行n-1位置，依次判断i + left +right 指向元素之和是否等于0，不断移动left和right指针到合适为止，去重后，添加进结果集。
边界条件判断
- 由于数组有序，如果nums[i] > 0，那么三数之和必定大于0，因此直接返回0
- 如果i + left + right > 0，说明right大了，因此需要right–
- 如果i + left + right < 0 ，说明left小了，需要left++
去重操作
- 如果 num[i] = num[i-1]，说明这个情况之前就已经考虑过了，直接continue
- 如果 num[left] = num[left+1]，left++
- 如果num[right] = num[right-1]，rigÏht–

时空分析：

时间复杂度: O(n^2)
空间复杂度: O(1)

代码实现

测试地址：https://leetcode.cn/problems/3sum/description/

双指针法：

class Solution {
public:
    // 函数threeSum用于找到数组中所有和为0的三元组
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result; // 存储结果的二维向量
        sort(nums.begin(), nums.end()); // 对数组进行排序

        // 遍历数组
        for (int i = 0; i < nums.size(); i++) {
            // 如果当前元素大于0，由于数组已排序，后续元素必然大于0，无法形成和为0的三元组
            if (nums[i] > 0) {
                return result; // 直接返回结果
            }
            // 如果当前元素与前一个元素相同，为了避免重复的三元组，跳过当前循环
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int left = i + 1; // 左指针从当前元素的下一个位置开始
            int right = nums.size() - 1; // 右指针指向数组末尾

            // 双指针遍历，寻找满足条件的三元组
            while (right > left) {
                // 如果三数之和大于0，右指针左移
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                } 
                // 如果三数之和小于0，左指针右移
                else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                } 
                // 如果找到和为0的三元组
                else {
                    result.push_back(vector<int>{nums[i], 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>> threeSum(vector<int>& nums) {
        vector<vector<int>> result; // 存储结果的二维向量
        sort(nums.begin(), nums.end()); // 对输入的数组进行排序

        // 找出a + b + c = 0
        // a = nums[i], b = nums[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break; // 如果当前元素大于0，则后续元素不可能与它组成和为0的三元组，直接退出循环
            }
            if (i > 0 && nums[i] == nums[i - 1]) { // 三元组元素a去重
                continue; // 如果当前元素与前一个元素相同，则跳过，避免重复的三元组
            }
            unordered_set<int> set; // 用于存储已检查过的元素，避免重复
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue; // 如果当前元素与前两个元素相同，则跳过，避免重复的三元组
                }
                int c = 0 - (nums[i] + nums[j]); // 计算c的值
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c}); // 如果c在set中，说明找到了一个有效的三元组
                    set.erase(c); // 从set中移除c，避免重复记录
                } else {
                    set.insert(nums[j]); // 如果c不在set中，将当前元素b插入set
                }
            }
        }
        return result; // 返回结果
    }
};

四数之和

题目描述

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

解题思路

总体思路

本题核心解题思路和((20240531101912-jee2kn5 ‘三数之和’))类似，都可以使用双指针法进行解题，需要重点关注以下几个剪枝逻辑：

由于target是任意数值，当target和num[k]均为负数的时候，四数相加后的值就可能等于target，因此不是单单判断num[k] > target，例如数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。需要判断target和num[k]是否非负。
如果前两个数值之和大于target，且targe和前两数之和均大于0，说明四数之和已经不可能等于targe了，可以直接进行剪枝操作。

时空分析：

时间复杂度: O(n^3)
空间复杂度: O(1)

代码实现

测试地址：https://leetcode.cn/problems/4sum/

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;
            }
            // 去重：如果当前数与前一个数相同，则跳过
            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; // 左指针从i的下一个位置开始
                int right = nums.size() - 1; // 右指针指向数组末尾
                while (right > left) {
                    // 计算四数之和，注意防止整数溢出
                    if ((long)nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--; // 如果和大于目标值，右指针左移
                    } 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; // 返回结果
    }
};

C1aySec

关注

9
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
第三章哈希表part02

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1。输出:2。
复制链接

扫一扫