Day 7 454.四数相加Ⅱ 383.赎金信 15.三数之和 18.四数之和总结

Salinoia

已于 2024-04-06 23:00:32 修改

阅读量799

点赞数 7

分类专栏：代码随想录训练营文章标签：算法 leetcode

于 2024-03-26 23:56:21 首次发布

本文链接：https://blog.csdn.net/qq_46025584/article/details/137061890

版权

代码随想录训练营专栏收录该内容

53 篇文章 0 订阅

订阅专栏

四数相加

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

四个不同的数组里的元素相加，不用考虑重复元素问题，只需得到a+b+c+d=0，则用一组哈希表存储a+b，再判断0-c-d的元素是否位于表中即可得到一组数据；由于输出的是元组数数量，则不仅需要判断是否和为零，还需要确定元素出现的次数，则使用map<key,value>结构，其中key中存放a+b的值，value中存放a+b出现的次数：

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int,int> umap;
        for(int a:A){
            for(int b:B){
                //umap.insert(make_pair(a + b, 1));
                umap[a+b]++;//C++中，umap[]和umap.at()均可访问map中的value;但是这种简写方式只有umap[]可以
            }
        }
        int count = 0;
        for(int c:C){
            for(int d:D){
                if(umap.find(0 - (c + d)) != umap.end()){
                    count += umap.at(0 - (c + d));
                    /*aMap[key]如果key不存在会添加key，不会抛出异常；
                      aMap.at(key)会检查key，如果不存在会抛出异常*/
                }
            }
        }
        return count;
    }
};

赎金信

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

给你两个字符串：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 <= 10^5
ransomNote 和 magazine 由小写英文字母组成

和异位词一样的思路，但是只需要判断ransomNote能否由magazine里的字符构成；

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26]={0};
        if(ransomNote.size() > magazine.size()){
            return false;//由于题目限制仅能使用一次，则当需要的密文字符数大于magazine能提供的字符时，直接失败
        }
        for(int i = 0; i < magazine.length(); i++){
            hash[magazine[i] - 'a']++;
        }
        for(int j = 0; j < ransomNote.length(); j++){
            hash[ransomNote[j] - 'a']--;
            if(hash[ransomNote[j] - 'a'] < 0){//如果此时对应的hash值小于0，说明使用的此字符次数必然大于一次
                return false;
            }
        }
        return true;
    }
};

三数之和

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

很显然，这和上面的四数相加不一样，这是同一数组上的相加操作且不允许出现重复元素，此时用哈希表存储的时候去重起来非常的麻烦，用双指针的方法则会简单很多，但是依然注意去重操作：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;//返回的是二维数组
        sort(nums.begin(),nums.end());
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > 0){
                return res;
            }
            //对a进行去重操作
            if(i > 0 && nums[i] == nums[i-1])    continue;
            /*为何不用nums[i]=nums[i+1]?因为如果是这样的话，当使用双指针思路遇上类似于
            -1 -1 2 这种序列的时候，就会出现直接漏掉三元组的情况，这显然是不允许的
            且此种判断方式由于因为防止数组下标-1的情况加入了i>0的限制条件
            就算遇到了全零数组，由于i>0的条件的判断所以至少会得到一组三元组*/
            int left = i + 1;
            int right = nums.size()-1;
            while(right > left){
                if(nums[i]+nums[left]+nums[right] > 0)  right--;
                else if(nums[i]+nums[left]+nums[right] < 0)  left++;
                else{
                    res.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    //对b c 进行去重操作;
                    //为什么此处去重要放在三元组之后？
                    //同理，如果遇到全零数组，那么一组三元组都无法得到，必须确保至少有一组答案后再去重
                    while(right > left && nums[left] == nums[left+1])   left++;
                    while(right > left && nums[right] == nums[right-1])   right--;
                    //找到答案后收缩左右指针
                    left++;
                    right--;
                }
            }        
        }
        return res;   
    }
};

四数之和

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

和三数之和思路一致，就是在三数之和的外面再套一层for循环，但需要注意的是这里要求的是和为target而不是0，所以进行剪枝操作时不能无脑判断nums[i]>target，需要考虑负数的存在:

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());
        for(int j = 0; j < nums.size(); j++){
            if(nums[j] >= 0 && nums[j] > target)  break;//剪枝操作
            if(j > 0 && nums[j] == nums[j-1])   continue;//去重操作
            for(int i = j + 1; i < nums.size(); i++){
                if(nums[j] + nums[i] >= 0 && nums[j] + nums[i] > target)    break;
                if(i > j + 1 && nums[i] == nums[i-1])   continue;
                int left = i + 1;
                int right = nums.size()-1;
                while(right > left){
                    //long防溢出
                    if((long)nums[j] + nums[i] + nums[left] + nums[right] > target)   right--;
                    else if((long)nums[j] + nums[i] + nums[left] + nums[right] < target) left++;
                    else{
                        res.push_back(vector<int>{nums[j],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 res;
    }
};

总结

一般来说哈希表都是用来快速判断一个元素是否出现集合里

数组作为哈希表：当场景给出元素明显很小或者范围很确定时，优先数组；

set作为哈希表：当数值大小不受限制时，数组可能会受系统栈空间限制或浪费大量内存；使用unordered_set 读写效率是最高的，当不需要对数据进行排序，且不要让数据重复重复时，优先unordered_set；

map作为哈希表：当不仅需要保存数值，还需要保存对应下标时，map就呼之欲出了；但是一定要记住，map虽然万能，但是占用的空间比数组大；

特殊情况还可以考虑双指针，只要是在线性数据结构里，双指针永远值得你信赖。

Salinoia

关注

7
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
Day 7 454.四数相加Ⅱ 383.赎金信 15.三数之和 18.四数之和总结

一般来说哈希表都是用来快速判断一个元素是否出现集合里数组作为哈希表：当场景给出元素明显很小或者范围很确定时，优先数组； set作为哈希表：当数值大小不受限制时，数组可能会受系统栈空间限制或浪费大量内存；使用unordered_set 读写效率是最高的，当不需要对数据进行排序，且不要让数据重复重复时，优先unordered_set； map作为哈希表：当不仅需要保存数值，还需要保存对应下标时，map就呼之欲出了；但是一定要记住，map虽然万能，但是占用的空间比数组大；特殊情况还可以考虑。
复制链接

扫一扫