454.四数相加II
题目描述:
给你四个整数数组 nums1
、nums2
、nums3
和 nums4
,数组长度都是 n
,请你计算有多少个元组 (i, j, k, l)
能满足:
0 <= i, j, k, l < n
nums1[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 < n
a
、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哥的讲解,更清晰一些。我也在同步学习中,暂不做分享,避免误导。