本文介绍了四个编程题目，包括四数相加II、赎金信、三数之和和四数之和，重点讲述了作者在解决问题前后的想法转变，难点在于数组操作、空间优化和去重策略，展示了如何利用双指针法、哈希表等技术解决此类问题。
目录
454.四数相加II
题目链接
（1）文字讲解：https://programmercarl.com/0454.四数相加II.html#思路
（2）视频讲解：
（3）题目链接：https://leetcode.cn/problems/4sum-ii/submissions/505046239/
看到题解之前的想法
不知道怎么做，四个数组挑元素加起来为0，我能想到的只有暴力
看到题解之后的想法
1.还是看题，题目的意思是，四个数组都必须有一个数字出来，才满足条件。那么就排除了很多只选1、2、3个数的情况。
2.把AB数组的每个元素分别相加，同理CD，其实问题就类似于，1.两数之和 ，在一个map里面存好AB所有元素分别相加得到的和和出现的次数，然后在CD所有元素分别相加得到的列表中找，0-元素和是否出现在map中，如果出现了，那么出现了几次就是有几个组合。
本题难点
1.四个数组问题的转化
2.map的使用
代码
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int, int> ab_map;
for(int num1 : nums1){
for(int num2 : nums2){
ab_map[num1+num2]++;
}
}
// unordered_map<int, int> cd_map;
int result = 0;
for(int num3 : nums3){
for(int num4 : nums4){
if(ab_map.find(-num3-num4) != ab_map.end()){
result += ab_map.find(-num3-num4)->second;
}
}
}
return result;
}
};
383. 赎金信
题目链接
（1）文字讲解：https://programmercarl.com/0383.赎金信.html
（2）视频讲解：
（3）题目链接：https://leetcode.cn/problems/ransom-note/description/
看到题解之前的想法
这个和242.有效的字母异位词很像，但是一个要求相等，一个要求包含。所以直接使用了相同的思路，因为只包含小写英文字母所以用了数组，然后存储magazine中的所有字母以及出现的次数。接着遍历ransomNote中的所有字母，数组中相应的字母数量–，如果任意一个字母的数量小于0，那么就是false，否则true。
看到题解之后的想法
为什么不用map？因为map空间消耗要比数组大一些的，map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！
本题难点
如果你写了242那么不难
代码
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
for(int i = 0; i < magazine.size(); i++){
record[magazine[i]-'a']++;
}
for(int i = 0; i < ransomNote.size(); i++){
record[ransomNote[i]-'a']--;
if(record[ransomNote[i]-'a']<0){
return false;
}
}
return true;
}
};
15. 三数之和
题目链接
（1）文字讲解：https://programmercarl.com/0015.三数之和.html#算法公开课
（2）视频讲解：
（3）题目链接：https://leetcode.cn/problems/3sum/submissions/506895228/
看到题解之前的想法
不会写，我能想到的就是先确定a，b，然后用哈希表确认列表里面存不存在0-a-b。但是这样会有问题，像之前的1.两数之和（遍历数组，然后看是否能找到0-a，如果能找到就返回结果，如果不能找到那就将a加入set）一样的方法，存入a+b，这样就会分不清a+b相等但是a和b不同的情况。
看到题解之后的想法
首先对nums进行从小到大的排序，然后检查num[0],如果这个大于0，说明后面的都大于0，那就直接return。
- 双指针法：
（1） 思路：总体思想和滑动窗口有一点像，用i遍历数组，每一个i，都用left从i+1开始，right从size-1开始，如果三个数相加大于0，那么right–，如果小于0，那么left++，一直到找到恰好为0的。
（2）去重：对于三个数都需要去重。i检查是否和i-1相等，如果相等那么就continue。left和right则需要在找到一个结果之后再去重，不然也没必要，毕竟去重就是为了不能有重复的答案。 - 哈希表法：
（1）思路：两层循环，先确定a，b两个数，然后再找0-a-b。（我之前的疑惑是，如果用set存储已有的a+b，那么区分不了原来的a，b是哪一个，其实这个只需要，每一个a都新建一个set就好，毕竟，遍历i的过程中a也在变化，肯定不是用一个set就能存的）
（2）去重：对于a的去重逻辑和上面一样。b和c的话去重逻辑是这样的：
if(j > i+2 && nums[j] == nums[j-1] && nums[j-1] == nums[j-2]){
continue;
}
tmp.erase(0-nums[i]-nums[j]);
一开始我也很不理解，为什么j一定要三个数字相等的时候才能continue，为什么不是两个就continue？原因是，如果遇到【-2，0，1，1，2】这样的数组，两个就continue就会pass掉-2，1，1这个结果，也就是，存在b=c这种情况，一定要到第三个数也相等的时候才能开始去重。
为什么双指针法的去重不需要考虑这个？
因为双指针的b，c去重逻辑是这样的：
while(left < right && nums[left] == nums[left+1]){
left++;
}
while(left < right && nums[right] == nums[right-1]){
right--;
}
如果遇到b=c的情况，left和right会同时分别取到1，这样就不会pass掉（如果不理解建议画图模拟一下就明白了）
本题难点
去重逻辑
代码
双指针法：
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;
sort(nums.begin(), nums.end());
if(nums[0] > 0){
return res;
}
for(int i = 0; i < nums.size(); i++){
if(i >= 1 && nums[i] == nums[i-1]){
continue;
}
int sum = nums[i];
int left = i+1, right = nums.size()-1;
while(left < right){
if(nums[i] + nums[left] + nums[right] < 0){
left++;
}else if(nums[i] + nums[left] + nums[right] > 0){
right--;
}else{
res.push_back(vector<int>{nums[i] ,nums[left], nums[right]});
while(left < right && nums[left] == nums[left+1]){
left++;
}
while(left < right && nums[right] == nums[right-1]){
right--;
}
right--;
left++;
}
}
}
return res;
}
};
哈希表法：
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;
sort(nums.begin(), nums.end());
if(nums[0] > 0){
return res;
}
for(int i = 0; i < nums.size(); i++){
if(i>0 && nums[i] == nums[i-1]){
continue;
}
unordered_set<int> tmp;
for(int j = i+1; j < nums.size(); j++){
if(j > i+2 && nums[j] == nums[j-1] && nums[j-1] == nums[j-2]){
continue;
}
if(tmp.find(0-nums[i]-nums[j]) != tmp.end()){
res.push_back(vector<int>{nums[i], nums[j], 0-nums[i]-nums[j]});
tmp.erase(0-nums[i]-nums[j]);
}else{
tmp.insert(nums[j]);
}
}
}
return res;
}
};
18. 四数之和
题目链接
（1）文字讲解：https://programmercarl.com/0018.四数之和.html#算法公开课
（2）视频讲解：
（3）题目链接：https://leetcode.cn/problems/4sum/submissions/507535525/
看到题解之前的想法
和上一题三数之和一样，双指针法，只不过需要多一层循环，先确定a，b
看到题解之后的想法
有几个小细节不一样的需要注意：
- 剪枝
if(nums[i] > target && nums[i] >= 0){
break;
}
if(nums[i]+nums[j]>target && nums[j] + nums[i] >= 0){
break;
}
以前只需要判断num[0]是否大于0，但是换成target后，注意，target可能小于零，也就是说，nums[i]在负数区域的时候可能越加越小，要注意不能单判断nums[i]>target之后就开始剪枝，要确定同时nums[i] >= 0才行。同时，因为多了一层循环，所以在第二层循环的时候也要剪枝。
- 去重
if(j > i+1 && nums[j] == nums[j-1]){
continue;
}
这里的去重一开始我写错了，写成了j > 1，但是这里不对，这里会在nums[i]==nums[j]的时候将nums[j]去掉，但是其实是可以取的（a=b），我们要去重的其实只有nums[j]==nums[j-1]，并且 > i+1的时候，这个时候才是b重复了。
本题难点
由于要取得数的变化导致的逻辑细节变化。
代码
双指针：
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> res;
sort(nums.begin(), nums.end());
// if(nums[0]> target){
// return res;
// }
for(int i = 0; i < nums.size()-1; i++){
if(nums[i] > target && nums[i] >= 0){
break;
}
if(i>0 && nums[i] == nums[i-1]){
continue;
}
for(int j = i+1; j < nums.size()-1; j++){
if(nums[i]+nums[j]>target && nums[j] + nums[i] >= 0){
break;
}
if(j > i+1 && nums[j] == nums[j-1]){
continue;
}
int left = j+1, right = nums.size()-1;
while(left< right){
if((long)nums[i]+nums[j]+nums[left]+nums[right] > target){
right--;
}else if((long)nums[i]+nums[j]+nums[left]+nums[right] < target){
left++;
}else{
res.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
while(left<right && nums[left] == nums[left+1]){
left++;
}
while(left<right && nums[right] == nums[right-1]){
right--;
}
left++;
right--;
}
}
}
}
return res;
}
};
扫一扫
736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
