454.四数相加II
题目描述：
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l)能满足：
0 <= i, j, k, l < nnums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例一:
输入：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
示例二：
输入：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
解题思路：
- 关键词提取：四个数组、长度n、相加为0
- 哈希表解法：
- 降维度。让四个数变成两个数，降低时间复杂度。
- 由于对数组下标没有大小的排序要求，可以是无序的。下标不能重复，但是元素可以重复，不需要考虑去重。
- 建立哈希表，key是相加的值，value是出现的次数
- 对前两个数组进行排列组合，将相加的值放置到哈希表中。
- 对后两个数组进行排序组合，将相加的值取负号，在哈希表中检索是否有对应的元素。若有，则根据value的值，做累加。
- 返回累加后的值。
代码如下：
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
// 定义一个哈希表，key存两数之和，value存次数
unordered_map<int,int> set;
int result = 0;
// 遍历前两个数组，将所有的情况遍历一遍
for(int i = 0; i < nums1.size(); i++) {
for(int j = 0; j < nums2.size(); j++) {
// 两数之和，存放到哈希表中
int sum = nums1[i] + nums2[j];
set[sum]++;
}
}
// 遍历后两个数组，将所有的情况遍历一遍
for(int i = 0; i < nums3.size(); i++) {
for(int j = 0; j < nums4.size(); j++) {
// 两数之和，并且跟目标值作差
int sum = nums3[i] + nums4[j];
sum = 0 - sum;
// 在哈希表中查找对应的值，若找到，就增加该值的出现次数
if(set.find(sum) != set.end()) {
result += set[sum];
}
}
}
return result;
}
};
总结：
-
一刷采用的是暴力解法，n^4，贼难写，代码debug也难。不堪回首，直接放弃。
-
代码随想录刷题提供降维思路，二刷的时候，思路很清晰，代码框架一下子就写出来，并且可以实现。
- 和之前的双指针法一样，遇到复杂的问题，想办法先降维。
- 考虑清楚边界条件，如重复、容器选择、键对的定义等。
383.赎金信
题目描述：
你可以选择使用单链表或者双链表，设计并实现自己的链表。
-
给你两个字符串：
ransomNote和magazine，判断ransomNote能不能由magazine里面的字符构成。如果可以，返回
true；否则返回false。magazine中的每个字符只能在ransomNote中使用一次。
示例一:
输入：ransomNote = "a", magazine = "b"
输出：false
示例二:
输入：ransomNote = "aa", magazine = "aab"
输出：true
提示：
1 <= ransomNote.length, magazine.length <= 105
ransomNote 和 magazine 由小写英文字母组成
解题思路：
- 关键词提取：字符只用1次、A字符串由B字符串中的字符构成
- 解析：不可重复、字符检索匹配，可采用哈希表
- 由于只由小写字母组成，可用数组做哈希表
- 一次遍历，将B字符串的元素存放到哈希表中，标注好次数
- 一次遍历，遍历A字符串，在哈希表中减去对应元素的值，若值小于零，说明B字符串中缺少该字符，报错返回即可
代码如下：
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
// 建立一个可以存储小写英文字母大小的数组
vector<int> stringMap(27, 0);
// 将B中的字符存进去
for(int i = 0; i < magazine.size(); i++) {
stringMap[magazine[i] - 'a']++;
}
// 在哈希表中删除A中的字符
for(int i = 0; i < ransomNote.size(); i++) {
stringMap[ransomNote[i] - 'a']--;
// 若哈希表中缺少A中的元素，报错
if(stringMap[ransomNote[i] - 'a'] < 0) {
return false;
}
}
return true;
}
};
总结：
-
二刷，解题思路还是不够清晰，耗时较长。但是写出来代码框架后，一次AC。
-
代码随想录提供的也是哈希法。
- 提到容器map和数组两者的区别，map的耗时会久一些。我的理解是，由于小写英文字母的数值固定，数组小，而且内存连续，所以做遍历的速度会比map要快。
- 有一个剪枝，这个是没有想到的。题解中，A是B的子序列，那么如果A长度超过B，就不需要做后续的检索了。
15.三数之和
题目描述：
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
**注意：**答案中不可以包含重复的三元组。
示例一:
输入：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] 。
注意，输出的顺序和三元组的顺序并不重要。
示例二：
输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。
提示：
3 <= nums.length <= 3000
-105 <= nums[i] <= 105
解题思路：
- 关键词提取：一个数组、下标不能重复、三数之和为零、返回值不重复、返回三元数组
- 解析：
- 对哈希法缺少一个头绪，因为要考虑重复、而且考虑返回三元数组，实在是没有思路。
- 但是想到双指针法可以应用，固定一个元素，剩余元素就通过双指针检索。可以降低复杂度。
- 解决重复的问题，将数组排序。刚好返回值可以不用考虑顺序问题。
- 一次遍历，检索第一个元素，增加去重逻辑。当前元素和前一个元素相同，跳过当前次遍历。
- 嵌套二次遍历，检索第二个和第三个元素，双指针法，从两边向中间靠拢。在检索到符合要求的三个元素时，下一次遍历要增加去重逻辑。同时，将三个元素保存到结果集中。
- 左指针去重逻辑：下一个元素和当前元素相同，需要将下标移动至下一个不同的元素处。
- 右指针去重逻辑：上一个元素和当前元素相同，需要将下标移动至上一个不同的元素处。
- 在检索到不符合要求时，若小于零，移动左指针，让总和增大，若大于零，移动右指针，让总和减小。
代码如下：
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
// 对数组排序
sort(nums.begin(), nums.end());
// 保存返回结果的二维数组
vector<vector<int>> result;
int sum = 0;
for(int i = 0; i < nums.size(); i++) {
// 对第一个元素做去重逻辑
if(i > 0 && nums[i] == nums[i - 1]) {
continue;
}
// 定义双指针
int left = i + 1;
int right = nums.size() - 1;
// 遍历第二个和第三个元素
while(left < right) {
// 对三个元素求和
sum = nums[i] + nums[left] + nums[right];
// std::cout << sum << nums[i] << nums[left] << nums[right] << std::endl;
// 符合要求
if(sum == 0) {
// std::cout << sum << nums[i] << nums[left] << nums[right] << std::endl;
// 保存结果集
result.push_back(vector<int>{nums[i], nums[left], nums[right]});
// 去重逻辑，将左指针移动到相同元素的最右侧
while(left < nums.size() - 1 && nums[left] == nums[left + 1]) {
left++;
}
// 去重逻辑，将右指针移动到相同元素的最左侧
while(right > 1 && nums[right] == nums[right - 1]) {
right--;
}
// 找到答案后，需要将左右指针都移动至不同元素，该类情况已经保存，不允许重复
left++;
right--;
}
else if(sum < 0) {
left++;
}
else if(sum > 0) {
right--;
}
else{;}
}
}
return result;
}
};
总结：
-
一刷和二刷都采用的双指针的解法，但是想起来一刷的时候遇到以下难点。
-
难点一：第二个元素和第三个元素的去重逻辑。
-
题解的代码太简洁，抄的时候没抄明白。是在while的条件判断中，用left++做了移动。我是通过频繁调试，多次打印，才发现这个。
-
最好是分开写，判断是判断，移动是移动。这样子逻辑会清晰很多。
-
-
难点二：第一个元素的去重逻辑。
-
没想明白为什么相同元素就要跳过遍历。所以一开始就漏了，后面看了题解之后才补上的。
-
去重逻辑也很巧妙，就是为什么是跟前一个元素比较而不是跟后一个元素比较。假如跟后一个元素比较，就会导致第二个元素跟第一个元素不同，会错过这种组合方式，但是题目中是允许三元组内的元素相同的，只是三元组之间不能相同。可以看下carl哥的讲解，会更清晰一些。
-
-
-
代码随想录提供哈希解法和双指针解法。
- 讲解视频：https://www.bilibili.com/video/BV1GW4y127qo/
- 双指针法中，有两个思考是我欠缺的。
- 剪枝：假如第一个元素就大于零，那么三数累加，必定大于零，就不需要再做后续的检索了。
- 去重：第二个元素和第三个元素的去重逻辑并没有提高效率，仅仅是将逻辑提前了而已。其实去重逻辑也一样可以放到while循环下去做，效率是一样的。
- 哈希表法：建议看carl哥讲解，我看不进去。。。
18.四数之和
题目描述：
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < na、b、c和d互不相同nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
示例一:
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例二：
输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]
提示：
1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109
解题思路：
- 关键词提取：一个数组、下标不能重复、四数之和为目标值、返回值不重复、返回四元数组
- 解析：
- 还是不考虑哈希法，太难了。
- 采用双指针法。基于三数之和去做，只需要再增加一个for循环遍历第二个元素。同时做好第二个元素的去重。
- 第三个元素和第四个元素，采用双指针去遍历，跟三数之和的遍历方式一样。
代码如下：
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
// 对数组排序
sort(nums.begin(), nums.end());
// 保存返回结果的二维数组
vector<vector<int>> result;
long sum = 0;
for(int i = 0; i < nums.size(); i++) {
// 对第一个元素做去重逻辑
if(i > 0 && nums[i] == nums[i - 1]) {
continue;
}
for(int j = i + 1; j < nums.size(); j++) {
// 对第二个元素做去重逻辑
if(j > i + 1 && nums[j] == nums[j - 1]) {
continue;
}
// 定义双指针
int left = j + 1;
int right = nums.size() - 1;
// 遍历第三个和第四个元素
while(left < right) {
// 对四个元素求和
sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
// std::cout << sum << nums[i] << nums[j] << nums[left] << nums[right] << std::endl;
// 符合要求
if(sum == target) {
// std::cout << sum << nums[i] << nums[left] << nums[right] << std::endl;
// 保存结果集
result.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
// 去重逻辑，将左指针移动到相同元素的最右侧
while(left < nums.size() - 1 && nums[left] == nums[left + 1]) {
left++;
}
// 去重逻辑，将右指针移动到相同元素的最左侧
while(right > 1 && nums[right] == nums[right - 1]) {
right--;
}
// 找到答案后，需要将左右指针都移动至不同元素，该类情况已经保存，不允许重复
left++;
right--;
}
else if(sum < target) {
left++;
}
else if(sum > target) {
right--;
}
else{;}
}
}
}
return result;
}
};
总结：
- 一刷和二刷都采用的双指针法，都是降维成三数之和，但是对于第二个元素的去重，需要着重注意一下。我的思路没有很清晰，是通过调试调出来的。
- 代码随想录提供双指针解法。
- 讲解视频：https://www.bilibili.com/video/BV1DS4y147US/
- 还是老毛病，剪枝的细节没有考虑到。建议直接看carl哥的讲解，更清晰一些。我也在同步学习中，暂不做分享，避免误导。
58
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
