Day6 哈希表02
一、四数相加Ⅱ
给你四个整数数组 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
- 首先定义 一个
unordered_map
,key放a和b两数之和,value
放a和b两数之和出现的次数。 - 遍历大A和大B数组,统计两个数组元素之和,和出现的次数,放到map中。
- 定义int变量
count
,用来统计a+b+c+d = 0
出现的次数。 - 在遍历大C和大D数组,找到如果
0-(c+d)
在map中出现过的话,就用count把map中key对应的value也就是出现次数统计出来。 - 最后返回统计值 count 就可以了
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
std::unordered_map<int, int> map;//key:a+b的数值,value:a+b数值出现的次数
// 遍历大A和大B数组,统计两个数组元素之和,和出现的次数,放到map中
for(int a : nums1){
for(int b : nums2){
map[a+b]++;
}
}
int count = 0;// 统计a+b+c+d = 0 出现的次数
// 在遍历大C和大D数组,找到如果 0-(c+d) 在map中出现过的话,就把map中key对应的value也就是出现次数统计出来。
for(int c : nums3){
for(int d : nums4){
int target = -(c + d);
if(map.find(target) != map.end()){
count += map[target];
}
}
}
return count;
}
};
-
map[a+b]++
将map
哈希表中键为a + b
的值加1。- 这行代码的目的是统计所有可能的两数之和出现的次数,以便后续检查是否有对应的值在哈希表中以使得总和为0。
-
count += map[target];
是对变量count
进行累加操作的语句。- 这行代码的目的是将哈希表
map
中键为target
的值加到count
上,也就是键target
的次数加到count
上。
- 这行代码的目的是将哈希表
二、赎金信
给你两个字符串: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、暴力法
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
for (int i = 0; i < magazine.length(); i++) {
for (int j = 0; j < ransomNote.length(); j++) {
// 在ransomNote中找到和magazine相同的字符
if (magazine[i] == ransomNote[j]) {
ransomNote.erase(ransomNote.begin() + j); // ransomNote删除这个字符
break;
}
}
}
// 如果ransomNote为空,则说明magazine的字符可以组成ransomNote
if (ransomNote.length() == 0) {
return true;
}
return false;
}
};
ransomNote.erase(ransomNote.begin() + j)
的意思是从字符串ransomNote
中删除第j
个字符。ransomNote.begin()
返回一个迭代器,指向字符串ransomNote
的第一个字符。
break
是因为一个magazine里面的字母只能抵消一个ransomNote里面的字母,一对一关系。
2、哈希法
本题哈希法思路与01中的”有效的字母异位词“基本上一模一样。
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
if (ransomNote.size() > magazine.size()) {
return false;
}
for (int i = 0; i < magazine.length(); i++) {
// 通过record数据记录 magazine里各个字符出现次数
record[magazine[i]-'a'] ++;
}
for (int j = 0; j < ransomNote.length(); j++) {
// 遍历ransomNote,在record里对应的字符个数做--操作
record[ransomNote[j]-'a']--;
// 如果小于零说明ransomNote里出现的字符,magazine没有
if(record[ransomNote[j]-'a'] < 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 。
当解决这个问题时,我们可以使用双指针法来降低时间复杂。
首先,对给定的数组进行排序,这样可以方便地移动指针。
然后,我们固定一个元素,将其作为三元组中的第一个元素。我们可以遍历数组,将当前元素设为固定元素。
接下来,使用两个指针,一个指针从固定元素的下一个位置开始,另一个指针从数组末尾开始。我们将这两个指针分别称为左指针和右指针。
我们通过移动左右指针来找到剩余两个元素,使得三个元素之和为0。
具体的移动规则如下:
- 如果三个元素之和等于0,那么我们找到了一个满足条件的三元组。我们将这个三元组加入结果集中。
- 如果三个元素之和小于0,说明左指针指向的元素太小,我们需要将左指针向右移动一位,以增加三个元素之和。
- 如果三个元素之和大于0,说明右指针指向的元素太大,我们需要将右指针向左移动一位,以减小三个元素之和。
在移动指针时,我们还需要注意跳过重复的元素,以避免得到重复的三元组。
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
int n = nums.size();
for(int i = 0; i < n; i++){
if(nums[i] > 0) break;
// 跳过重复的固定元素
if(i > 0 && nums[i] == nums[i-1]) continue;
int left = i + 1;
int right = n - 1;
while(left < right){
int total = nums[i] + nums[left] + nums[right];
if(total == 0){
// 找到满足条件的三元组
result.push_back({nums[i], nums[left], nums[right]});
// 跳过重复的左指针元素
while(left < right && nums[left] == nums[left+1]){
left++;
}
// 跳过重复的右指针元素
while(left < right && nums[right] == nums[right-1]){
right--;
}
// 移动指针
left++;
right--;
}
else if(total < 0){
// 左指针向右移动
left++;
}
else{
// 右指针向左移动
right--;
}
}
}
return result;
}
};
四、四数之和
给你一个由 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]]
解决这个问题可以使用类似于三数之和的双指针法的思路。
首先,对数组进行排序,这样可以方便地移动指针。
然后,使用两层嵌套的循环来固定前两个元素,将其作为四元组中的前两个元素。
在内层循环中,使用双指针来找到后两个元素,使得四个元素之和等于目标值。
具体的步骤如下:
- 对数组进行排序。
- 使用两层嵌套的循环,分别遍历数组中的前两个元素。在外层循环中,将当前元素设为第一个固定元素;在内层循环中,将当前元素设为第二个固定元素。
- 使用两个指针,一个指针从第二个固定元素的下一个位置开始,另一个指针从数组末尾开始。我们将这两个指针分别称为左指针和右指针。
- 通过移动左右指针来找到后两个元素,使得四个元素之和等于目标值。
- 如果四个元素之和等于目标值,那么我们找到了一个满足条件的四元组。将这个四元组加入结果集中。
- 如果四个元素之和小于目标值,说明左指针指向的元素太小,我们需要将左指针向右移动一位,以增加四个元素之和。
- 如果四个元素之和大于目标值,说明右指针指向的元素太大,我们需要将右指针向左移动一位,以减小四个元素之和。
- 在移动指针时,需要注意跳过重复的元素,以避免得到重复的四元组。
- 继续遍历数组,重复步骤2至步骤5,直到遍历完所有可能的组合。
最后,返回结果集。
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;
}
};
五、总结
3、4题完全没有思路,看了解析之后自己也不会写,感觉有些太有难度了呜呜!