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
提示:
-
n == nums1.length
-
n == nums2.length
-
n == nums3.length
-
n == nums4.length
-
1 <= n <= 200
-
2 28 2^{28} 228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2 28 2^{28} 228
思路
不需要考虑去重,相同的数字可以来自不同的数组
一次遍历两个数组,比如遍历 nums1(A) + nums2(B),放到一个集合里,在遍历 nums3© + num4(D) 数组时,判断有没有想要的元素,如果有说明
数据结构选择
数组内数值不可控,可能会很大,所以只考虑 set 或者 map
不仅要统计 a+b 有没有出现过,还要统计出现过的次数,key 去存(a+b)是否出现过,此时需要 value 存出现过的次数,所以用 map
在遍历 C+D 时,要查 0-(c+d),即出现符合题目规则的四元组
如果出现过,统计四元组数量 count 计数 + value 里所存的值
代码实现
-
unordered_map 定义一个 map
-
for 遍历 A 数组
- for 遍历 B 数组
- a+b 存到 map
map[a+b]++;
:如果出现过,value++,如果没出现过,insert
- a+b 存到 map
- for 遍历 B 数组
-
定义 count 计数 = 0
-
for 遍历 C
- for 遍历 D
- target = 0-(c+d)
- if map 中有没有出现 target,如果出现过 != map.end()
count += map[target]
:count 加 map 对应 key 的value
- for 遍历 D
-
return count
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int, int> umap;
for(int a : nums1){
for(int b : nums2){
umap[a+b]++;
}
}
int count = 0;
for(int c : nums3){
for(int d : nums4){
if(umap.find(0-(c+d)) != umap.end()){
count += umap[0-(c+d)];
}
}
}
return count;
}
};
383. 赎金信
与 242.有效的字母异位词是一个思路
题目
给你两个字符串:ransomNote
和 magazine
,判断 ransomNote
能不能由 magazine
里面的字符构成。
如果可以,返回 true
;否则返回 false
。
magazine
中的每个字符只能在 ransomNote
中使用一次。
示例:
输入:ransomNote = "a", magazine = "b"
输出:false
示例 2:
提示:
-
1 <= ransomNote.length, magazine.length <= 105
-
ransomNote
和magazine
由小写英文字母组成
思路
首先注意到提示中,两个字符串都是由小写英文字母组成,所以数据结构有使用数组的可能性,再看需不需要保存两个数值,并不需要返回下标位置,所以用不到 map。再看需不需要降重操作,也不需要,所以也不用 unordered_set 来提高效率。最后选用数组。
其次是留意两个字符串的长度,如果 ransomNote 比 magazine 长,那肯定是 false。
如果 ransomNote 比 magazine 短,再去定义一个 hash 数组,遍历 ransmNote 的字符,计数++,再遍历 magezine 字符,计数–,最后 hash 中有元素 < 0,说明 false
我的易错思路
中间有一个容易绕进去的地方,就是“magazine
中的每个字符只能在 ransomNote
中使用一次”这一句话,怎么保证能够实现,然后发现用 242.有效的字母异位词 的方法本来就解决了这部分问题,这是之前没有留意过的。
还有就是思考了一会要是 magazine 中有 ransomNote 没出现过的元素怎么办,一开始是想先 遍历 ransomNote,然后 hash 数组都是 0 返回 false,但这样会出现负数的现象,后面参考了解题思路才意识到要先遍历 magazine,这样判断是否出现负数没有的话就是 true。
代码实现
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int hash[26] = {0};
if(ransomNote.size() > magazine.size()){
return false;
}
for(int i = 0; i < magazine.size(); i++){
hash[magazine[i] - 'a']++;
}
for(int i = 0; i < ransomNote.size(); i++){
hash[ransomNote[i] - 'a']--;
if(hash[ransomNote[i] - 'a'] < 0){
return false;
}
}
return true;
}
};
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] 。
注意,输出的顺序和三元组的顺序并不重要。
提示:
-
3 <= nums.length <= 3000
-
-10(5) <= nums[i] <= 10(5)
思路
哈希法
哈希法去重细节太多,容易出 bug
与求两数之和类似,先遍历两个数组存进 map 里,遍历第三个数组的时候,去 map 里找符合 target 的数,但最麻烦的点是需要去重
双指针法
首先对数组进行排序,排序原因举例:i 是 a 组,left 指针是 b 组,right 指针式 c 组,如果 nums[i] + nums[left] + nums[right] > 0,就可以用 right-- 的方式缩小范围。如果 < 0,则可以 left++。
= 0 就存放到 result 数组,存放可能 n 个符合条件的结果集
但去重是关键
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xbFEEkk0-1664293368680)(assets/1664293236248-3.gif)]
代码实现
-
定义二维数组 result 存放结果集
-
对输入数组从小到大排序
sort(nums);
-
for 遍历数组
- 剪枝:if nums[i]>0,直接 return false,因为后面的怎么加都不可能大于 0
- 去重:if i>0 同时 nums[i] == nums[i-1],说明 a 重复了,continue
- 用 i-1 而不是 i+1 的原因是,当数组元素比较少的时候,不会影响到 left 和 right
- left = i+1
- right = nums.size -1
- while 遍历,当 right > left
- if nums[i] + nums[left] + nums[right] > 0,right–
- else if <0,left++
- else =0,result.push
- while right > left 同时 right[i] == right[i-1],持续 right–
- 同理left[i]==left[i-1],left++
- right–;
- left++;
-
return result
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
for(int i = 0; i < nums.size(); i++){
if(nums[i] > 0)return result;
if(i > 0 && nums[i] == nums[i - 1])continue;
int left = i + 1;
int right = nums.size() - 1;
while(right > 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]});
while(right > left && nums[right] == nums[right - 1])right--;
while(right > left && nums[left] == nums[left + 1])left++;
right--;
left++;
}
}
}
return result;
}
};
易错
总会忘记要 if(i > 0……
,只有大于 0 才能 -1!
18. 四数之和
需要与 454.四数相加II 对比区别,想明白为什么四数相加会更简单
题目
给你一个由 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]]
提示:
-
1 <= nums.length <= 200
-
-10(9) <= nums[i] <= 10(9)
-
-10(9) <= target <= 10(9)
思路
延续三数之和的思路,在 i, left, right 的基础上,多套一层 k
k 和 i 是确定的,靠 left 和 right 不断往中间靠,去寻找合适的四元组
剪枝
target 是输入的数,所以不能直接 nums[k] > target 就 continue,因为 target 可能是负数,两个负数相加可能会更小
代码实现
-
k 剪枝 if(nums[k] > target && nums[k] >= 0) break
-
k 去重 if(k > 0 && nums[k] == nums[k-1]) continue
-
for 遍历 i,i = k+1 初始 > 这一个循环中,nums[k] + nums[i] 是一个整体
- i+k 剪枝 if(nums[k] + nums[i] > target、>=0) break
- i+k 去重 if(i > k+1 && nums[i] == nums[i -1]) continue
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;
if(k > 0 && nums[k] == nums[k - 1])continue;
for(int i = k + 1; i < nums.size(); i++){
if(nums[i] + nums[k] > target && nums[i] + nums[k] >= 0)break;
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--;
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]});
while(right > left && nums[right] == nums[right - 1])right--;
while(right > left && nums[left] == nums[left + 1])left++;
right--;
left++;
}
}
}
}
return result;
}
};
总结
总结主要是想重新梳理一下什么情况用什么数据结构,自己在刷题过程中对这一部分的反应并不是很快,需要加强记忆。
-
如果数值比较小,可以考虑数组
-
如果需要去重,考虑 unordered_set
- 另外两个底层是树,还有一个查找的过程,效率低
-
如果需要 key 和 value,优先考虑 unordered_map
- map 和 multi_map 的 key 是有序的,看看题目需不需要有序