四数相加
给你四个整数数组 nums1
、nums2
、nums3
和 nums4
,数组长度都是 n
,请你计算有多少个元组 (i, j, k, l)
能满足:
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 1:
输入: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
示例 2:
输入: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
四个不同的数组里的元素相加,不用考虑重复元素问题,只需得到a+b+c+d=0,则用一组哈希表存储a+b,再判断0-c-d的元素是否位于表中即可得到一组数据;由于输出的是元组数数量,则不仅需要判断是否和为零,还需要确定元素出现的次数,则使用map<key,value>结构,其中key中存放a+b的值,value中存放a+b出现的次数:
class Solution {
public:
int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
unordered_map<int,int> umap;
for(int a:A){
for(int b:B){
//umap.insert(make_pair(a + b, 1));
umap[a+b]++;//C++中,umap[]和umap.at()均可访问map中的value;但是这种简写方式只有umap[]可以
}
}
int count = 0;
for(int c:C){
for(int d:D){
if(umap.find(0 - (c + d)) != umap.end()){
count += umap.at(0 - (c + d));
/*aMap[key]如果key不存在会添加key,不会抛出异常;
aMap.at(key)会检查key,如果不存在会抛出异常*/
}
}
}
return count;
}
};
赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串,判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成,返回 true ;否则返回 false。
给你两个字符串:ransomNote
和 magazine
,判断 ransomNote
能不能由 magazine
里面的字符构成。
如果可以,返回 true
;否则返回 false
。
magazine
中的每个字符只能在 ransomNote
中使用一次。
示例 1:
输入:ransomNote = "a", magazine = "b"
输出:false
示例 2:
输入:ransomNote = "aa", magazine = "ab"
输出:false
示例 3:
输入:ransomNote = "aa", magazine = "aab"
输出:true
提示:
1 <= ransomNote.length, magazine.length <= 10^5
ransomNote
和magazine
由小写英文字母组成
和异位词一样的思路,但是只需要判断ransomNote能否由magazine里的字符构成;
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int hash[26]={0};
if(ransomNote.size() > magazine.size()){
return false;//由于题目限制仅能使用一次,则当需要的密文字符数大于magazine能提供的字符时,直接失败
}
for(int i = 0; i < magazine.length(); i++){
hash[magazine[i] - 'a']++;
}
for(int j = 0; j < ransomNote.length(); j++){
hash[ransomNote[j] - 'a']--;
if(hash[ransomNote[j] - 'a'] < 0){//如果此时对应的hash值小于0,说明使用的此字符次数必然大于一次
return false;
}
}
return true;
}
};
三数之和
给你一个整数数组 nums
,判断是否存在三元组 [nums[i], nums[j], nums[k]]
满足 i != j
、i != k
且 j != k
,同时还满足 nums[i] + nums[j] + nums[k] == 0
。请
你返回所有和为 0
且不重复的三元组。
**注意:**答案中不可以包含重复的三元组。
示例 1:
输入: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] 。
注意,输出的顺序和三元组的顺序并不重要。
示例 2:
输入:nums = [0,1,1]
输出:[]
解释:唯一可能的三元组和不为 0 。
示例 3:
输入:nums = [0,0,0]
输出:[[0,0,0]]
解释:唯一可能的三元组和为 0 。
很显然,这和上面的四数相加不一样,这是同一数组上的相加操作且不允许出现重复元素,此时用哈希表存储的时候去重起来非常的麻烦,用双指针的方法则会简单很多,但是依然注意去重操作:
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;//返回的是二维数组
sort(nums.begin(),nums.end());
for(int i = 0; i < nums.size(); i++){
if(nums[i] > 0){
return res;
}
//对a进行去重操作
if(i > 0 && nums[i] == nums[i-1]) continue;
/*为何不用nums[i]=nums[i+1]?因为如果是这样的话,当使用双指针思路遇上类似于
-1 -1 2 这种序列的时候,就会出现直接漏掉三元组的情况,这显然是不允许的
且此种判断方式由于因为防止数组下标-1的情况加入了i>0的限制条件
就算遇到了全零数组,由于i>0的条件的判断所以至少会得到一组三元组*/
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{
res.push_back(vector<int>{nums[i], nums[left], nums[right]});
//对b c 进行去重操作;
//为什么此处去重要放在三元组之后?
//同理,如果遇到全零数组,那么一组三元组都无法得到,必须确保至少有一组答案后再去重
while(right > left && nums[left] == nums[left+1]) left++;
while(right > left && nums[right] == nums[right-1]) right--;
//找到答案后收缩左右指针
left++;
right--;
}
}
}
return res;
}
};
四数之和
给你一个由 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
你可以按 任意顺序 返回答案 。
示例 1:
输入:nums = [1,0,-1,0,-2,2], target = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2:
输入:nums = [2,2,2,2,2], target = 8
输出:[[2,2,2,2]]
和三数之和思路一致,就是在三数之和的外面再套一层for循环,但需要注意的是这里要求的是和为target而不是0,所以进行剪枝操作时不能无脑判断nums[i]>target,需要考虑负数的存在:
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> res;
sort(nums.begin(),nums.end());
for(int j = 0; j < nums.size(); j++){
if(nums[j] >= 0 && nums[j] > target) break;//剪枝操作
if(j > 0 && nums[j] == nums[j-1]) continue;//去重操作
for(int i = j + 1; i < nums.size(); i++){
if(nums[j] + nums[i] >= 0 && nums[j] + nums[i] > target) break;
if(i > j + 1 && nums[i] == nums[i-1]) continue;
int left = i + 1;
int right = nums.size()-1;
while(right > left){
//long防溢出
if((long)nums[j] + nums[i] + nums[left] + nums[right] > target) right--;
else if((long)nums[j] + nums[i] + nums[left] + nums[right] < target) left++;
else{
res.push_back(vector<int>{nums[j],nums[i],nums[left],nums[right]});
while(right > left && nums[left] == nums[left+1]) left++;
while(right > left && nums[right] == nums[right-1]) right--;
left++;
right--;
}
}
}
}
return res;
}
};
总结
一般来说哈希表都是用来快速判断一个元素是否出现集合里
数组作为哈希表:当场景给出元素明显很小或者范围很确定时,优先数组;
set作为哈希表:当数值大小不受限制时,数组可能会受系统栈空间限制或浪费大量内存;使用unordered_set 读写效率是最高的,当不需要对数据进行排序,且不要让数据重复重复时,优先unordered_set;
map作为哈希表:当不仅需要保存数值,还需要保存对应下标时,map就呼之欲出了;但是一定要记住,map虽然万能,但是占用的空间比数组大;
特殊情况还可以考虑双指针,只要是在线性数据结构里,双指针永远值得你信赖。