代码随想录day7 | LeetCode454. 四数相加 II、LeetCode383. 赎金信、LeetCode15. 三数之和、LeetCode18. 四数之和
可以先看前两题,后两题我并没有理解透彻,所以只放了链接
头好疼啊,是不是要长脑子了
等脑子长好了再把后两题补上吧
四数相加II
题目链接:LeetCode454. 四数相加 II
自己敲
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
std::multimap<int,pair<int,int>> map1,map2;
//num1,num2之和及对应下标存入map1
for(int i=0;i<nums1.size();i++){
for(int j=0;j<nums2.size();j++){
map1.insert(pair<int,pair<int,int>>(nums1[i]+nums2[j],pair(i,j)));
}
}
//num3,num4之和及对应下标存入map2
for(int i=0;i<nums3.size();i++){
for(int j=0;j<nums4.size();j++){
map2.insert(pair<int,pair<int,int>>(nums3[i]+nums4[j],pair(i,j)));
}
}
int count=0;
//在map2中找0-num1与num2之和
for(std::multimap<int,pair<int,int>>::iterator it=map1.begin();it!=map1.end();it++){
auto iter = map2.find(0-it->first);
if(iter!=map2.end()){
count++;
}
}
return count;
}
};
有部分样例未通过
分析问题:
std::multimap
的 find()
它只返回第一个匹配的元素的迭代器。由于 std::multimap
允许键的重复,如果存在多个具有相同键的元素,find()
只会定位到第一个出现的元素。
修改find处代码
for(std::multimap<int,pair<int,int>>::iterator it=map1.begin();it!=map1.end();it++){
for(std::multimap<int,pair<int,int>>::iterator it2=map2.begin();it2!=map2.end();it2++){
if(it->first+it2->first==0){
count++;
}
}
}
然后就超时了
可见使用multi_map
并不是一个好选择
LeetCode提交时用例更多,有时候测试过了提交未通过
看题解
- 首先定义 一个
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>& 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;
}
};
用unordered_map
存,由于题中可能出现重复(A,B数组中两元素之和相同时,可能出现不同的a,b元素下标匹配对),所以用value
来存出现次数,妙!
总结
-
本题场景仍可以采用
unordered_map
保存,重复key
时用value
存重复个数即可 -
key
不重复的map
可以采用find()
方法来查找元素,因为find()
它只返回第一个匹配的元素的迭代器,当所选数据结构允许key
重复时,find()
会查找不全 -
for (int c : C) { for (int d : D) { if (umap.find(0 - (c + d)) != umap.end()) { count += umap[0 - (c + d)]; } } }
find()
放在双循环中使用,无需单独把c+d
另存到容器中(均为找0-(c+d)
与其单独用双循环把c+d
算出并保存,不如直接在双循环使用c+d
),明白变量的作用再考虑如何“高效保存” -
归根结底还是由于思路不太清晰,走一步看一步,导致代码未设计好
赎金信
题目链接:LeetCode383. 赎金信
自己敲
本题和[242.有效的字母异位词]非常像,建议对照学习
此处有 242.有效的字母异位词 题目和题解
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int a[26]={0};
for(int i=0;i<magazine.size();i++){
a[magazine[i]-'a']++;
}
for(int i=0;i<ransomNote.size();i++){
a[ransomNote[i]-'a']--;
if(a[ransomNote[i]-'a']<0){
return false;
}
}
return true;
}
};
看题解
[242.有效的字母异位词]相当于求 字符串a 和 字符串b 是否可以相互组成 ,而这道题目是求 字符串a能否组成字符串b,而不用管字符串b 能不能组成字符串a。
暴力解法
双层for循环寻找
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;
}
};
哈希
因为题目说只有小写字母,那可以采用空间换取时间的哈希策略,用一个长度为26的数组来记录magazine里字母出现的次数。
使用map的空间消耗要比数组大一些的,因为map要维护红黑树或者哈希表,而且还要做哈希函数,是费时的!数据量大的话就能体现出来差别了。 所以数组更加简单直接有效
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
//add
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;
}
};
和我思路一样,但是题解代码在循环前多了一次判断
if (ransomNote.size() > magazine.size()) {
return false;
}
这次判断可以快速解决一种情况(ransomNote
长度大于magazine
时,ransomNote
不可能由magazine
构成)
总结
- 解题中注意分情况,可以用一些判断快速解决问题
三数之和
题目链接:LeetCode15. 三数之和
梦破碎的地方
自己敲
思路:双层for
循环遍历数组,当j!=k
时,将nums[j]
和nums[k]
组成的对存入pair<pair<int,int>,pair<int,int>>
第一个元素,将j
,k
下标存入第二个元素
找到满足nums[i]==0-nums[j]-nums[k]
并且i!=j,i!=k
的元素
嵌套pair
的使用方法:
// 创建嵌套的 pair 对象
std::pair<std::pair<int, int>, std::pair<int, int>> nestedPair =
{{{1, 2}}, { {3, 4} }};
// 访问第一个嵌套 pair 的第一个元素
int firstElementOfFirstPair = nestedPair.first.first;
// 访问第二个嵌套 pair 的第一个元素
int firstElementOfSecondPair = nestedPair.second.first;
没时间了直接看题解
看题解
哈希解法
两层for循环就可以确定 a 和b 的数值了,可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过,其实这个思路是正确的,但是我们有一个非常棘手的问题,就是题目中说的不可以包含重复的三元组。
把符合条件的三元组放进vector中,然后再去重,这样是非常费时的,很容易超时,也是这道题目通过率如此之低的根源所在。
去重的过程不好处理,有很多小细节,如果在面试中很难想到位。
时间复杂度可以做到O(n^2),但还是比较费时的,因为不好做剪枝操作。
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;
}
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]);
if (set.find(c) != set.end()) {
result.push_back({nums[i], nums[j], c});
set.erase(c);// 三元组元素c去重
} else {
set.insert(nums[j]);
}
}
}
return result;
}
};
双指针
其实这道题目使用哈希法并不十分合适,因为在去重的操作中有很多细节需要注意,在面试中很难直接写出没有bug的代码。
而且使用哈希法 在使用两层for循环的时候,能做的剪枝操作很有限,虽然时间复杂度是O(n^2),也是可以在leetcode上通过,但是程序的执行时间依然比较长 。
接下来我来介绍另一个解法:双指针法,这道题目使用双指针法 要比哈希法高效一些,那么来讲解一下具体实现的思路。
拿这个nums数组来举例,首先将数组排序,然后有一层for循环,i从下标0的地方开始,同时定一个下标left 定义在i+1的位置上,定义下标right 在数组结尾的位置上。
依然还是在数组中找到 abc 使得a + b +c =0,我们这里相当于 a = nums[i],b = nums[left],c = nums[right]。
接下来如何移动left 和right呢, 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了,因为数组是排序后了,所以right下标就应该向左移动,这样才能让三数之和小一些。
如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了,left 就向右移动,才能让三数之和大一些,直到left与right相遇为止。
时间复杂度:O(n^2)。
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[left], c = nums[right]
for (int i = 0; i < nums.size(); i++) {
// 排序之后如果第一个元素已经大于零,那么无论如何组合都不可能凑成三元组,直接返回结果就可以了
if (nums[i] > 0) {
return result;
}
// 错误去重a方法,将会漏掉-1,-1,2 这种情况
/*
if (nums[i] == nums[i + 1]) {
continue;
}
*/
// 正确去重a方法
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while (right > left) {
// 去重复逻辑如果放在这里,0,0,0 的情况,可能直接导致 right<=left 了,从而漏掉了 0,0,0 这种三元组
/*
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
*/
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 (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
// 找到答案时,双指针同时收缩
right--;
left++;
}
}
}
return result;
}
};
总结
头好疼啊,是不是要长脑子了
四数之和
题目链接:LeetCode18. 四数之和
自己敲
乍一看就是上一题的扩展
看题解
最后两题没搞清楚,等脑子长好了再回来补上(预计这周末有时间能补上,如果那时候我能学会的话)
nums[left] == nums[left + 1]) left++;
// 找到答案时,双指针同时收缩
right--;
left++;
}
}
}
return result;
}
};
### 总结
头好疼啊,是不是要长脑子了
## 四数之和
### 自己敲
乍一看就是上一题的扩展
### 看题解
最后两题没搞清楚,等脑子长好了再回来补上(预计这周末有时间能补上,如果那时候我能学会的话)