代码随想录day 7刷题哈希表 977 209 59

最新推荐文章于 2024-05-23 10:01:13 发布

深度学习渣

最新推荐文章于 2024-05-23 10:01:13 发布

阅读量126

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/qq_45228845/article/details/131027837

版权

代码随想录day 7刷题哈希表 977 |209 |59

第454题.四数相加II

力扣题目链接(opens new window)

给定四个包含整数的数组列表 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

分析：本题只需要计算有多少个组合使得和为零，并不需要求出相应下标。需要注意的是，与另外一个四数之和题目不同的是，这是在四个数组中查找的，所以不考虑重复数字的情况。在一个数组中，我们是需要考虑数组的重复情况的。

思路：

1.惯用思路是，利用四个for进行累加，但是这种方式在四个循环下特别费时。

2.另外一个则是根据双指针思路来做，固定两个数，再对其他两个数进行操作。

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;
    }
};

383. 赎金信

力扣题目链接(opens new window)

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

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

注意：

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

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

分析：

1.要求第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成，即ransom 中的字母一定在magazine中能找到。而且告诉我们每个字母只能用一次，即使ab,aa这样也是不能组成的。

2.这个题与前面的242字母异同位相似，需要判断字母是否互相都出现，本题则是判断ransom的字母在magzine出现。一个是双向有，一个是单向有。

3.所以我们依然用哈希数组来表示r[26]

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        
        int r[26] = {0};
        for (int i = 0; i < magazine.size(); i++) {
            r[magazine[i] - 'a']++;
        }
        
        for (int j = 0; j < ransomNote.size(); j++) {
            r[ransomNote[j] - 'a']--;
            if (r[ransomNote[j] - 'a'] < 0) {
                return false;
            }
        }
        
        return true;
    }
};
特别注意这段循环
     
for (int j = 0; j < ransomNote.size(); j++) {
            r[ransomNote[j] - 'a']--;
            if (r[ransomNote[j] - 'a'] < 0) {
                return false;
            }
        }
        
我们是使用r[ransomNote[j] - 'a'] ,还是r[magazine[j] - 'a']   
如果可以构成则说明ransomNote中的元素magazine中都有，则需要对magazine进行操作。

第15题. 三数之和

给你一个整数数组 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
$10^5$ <= nums[i] <= $10^5$

**分析：**这题仍然需要返回数组中具体元素，使用哈希表中的set会保留重复的值。擦除重复字母操作又会比较耗时。

另外一个思路是：双指针，但是双指针需要排序固定一个数，移动左右两个指针，关键我们要去除重复的三元组。

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) return result;
        
        int l = i + 1;
        int r = nums.size() - 1;
        if(i > 0 && nums[i] == nums[i - 1]) continue; // 去除重复元素
        while(l < r){
            if(nums[i] + nums[l] + nums[r] > 0) r--;
            else if(nums[i] + nums[l] + nums[r] < 0) l++;
            else{
                result.push_back(vector<int>{nums[i],nums[l],nums[r]} );
                while(r > l && nums[r] == nums[r - 1]) r--;
                while(r > l && nums[l] == nums[l + 1]) l++;
                l++;
                r--; // 注意得到满足条件的数后要减减不是 ++
                
            }
        }
        
    }
    return result;
    
}    
    
};


逻辑梳理：排序，固定i 在移动左右两个指针。
1.先排序 sort(begin,end)
2.循环 for(int i = 0;i < nums.size();) 固定 i
3.判断数组中nums[i]是否重复，重复就跳过 if(i > 0 && nums[i] == nums[i - 1]) continue
4.在内部循环更新左右指针。
(1)左右指针不能越界while(left < right)
(2)分三个情况 
    1.三数之和大于0 更新右指针r++;
    2.三数之和小于0 更新左指针l--;
    3.三数之和等于0 更新左右指针 而且要注意内部数组重复的情况。

第18题. 四数之和

力扣题目链接(opens new window)

题意：给定一个包含 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] ]

分析：前面梦开始的地方我们引入了双指针法，在不需要返回数组下标的和的相加题目中，都可以用双指针法。三个数求和我们就固定第一个数，四个数求和我们就固定开头和结尾的数然后更新,当然也可以固定开头的两个数。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        int n = nums.size();
        sort(nums.begin(), nums.end());
        
        for (int i = 0; i < n; ++i) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            
            for (int j = n - 1; j > i; --j) {
                if (j < n - 1 && nums[j] == nums[j + 1]) {
                    continue;
                }
                
                int l = i + 1;
                int r = j - 1;
                
                while (l < r) {
                    long sum = (long)nums[i] + nums[j] + nums[l] + nums[r];// 注意此项可能溢出
                    if (sum > target) {
                        --r;
                    } else if (sum < target) {
                        ++l;
                    } else {
                        res.push_back({nums[i], nums[j], nums[l], nums[r]});
                        while (r > l && nums[r] == nums[r - 1]) {
                            --r;
                        }
                        while (r > l && nums[l] == nums[l + 1]) {
                            ++l;
                        }
                        --r;
                        ++l;
                    }
                }
            }
        }
        
        return res;
    }
};

深度学习渣

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录day 7刷题哈希表 977 209 59

给定四个包含整数的数组列表 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的情况。在一个数组中，我们是需要考虑的。1.惯用思路是，利用四个for进行累加，但是这种方式在四个循环下特别费时。
复制链接

扫一扫