● 454.四数相加II
● 383. 赎金信
● 15. 三数之和
● 18. 四数之和
总结
对于查，某个元素是否在集合中出现过，哈希法是非常高效的方法
但是对于需要去重的情况下，哈希法要注意太多细节，很难完美写完，因此采用双指针法，更便于去重
● 454.四数相加II
/*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
*/
#include <unordered_map>
class Solution_454 {
public:
/*
* 暴力解法四层for循环，显然时间复杂度很高
* 给出等式，可以根据等式遍历部分数组然后匹配查找需要的另外部分数组元素，即查找某个元素在集合中是否出现过，可以用哈希表，并且不用去重。
* 因为四个独立数组，即使用哈希表也需要遍历求和，只是可以分开求，所以最好是两两分组，最多是两层for循环
* 那思路就是用map保存两个数组之和及其出现次数，再遍历另外两个数组和，在map查询满足等式的元素是否存在，出现了多少次，从而得到结果
* 使用无序map,底层实现是哈希，搜索效率高
* O(n^2)
*/
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int, int> record_map;
for(auto a : nums1){//map保存两个数组之和及其出现次数
for(auto b : nums2)
++record_map[a + b];
}
int count = 0;
for(auto c : nums3){
for(auto d : nums4){
auto itr = record_map.find((0 - (c + d)));
if(itr != record_map.end())
count += itr->second;
}
}
return count;
}
};
● 383. 赎金信
/*
383. 赎金信
简单
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
*/
#include <unordered_set>
class Solution_383 {
public:
/*
*查找某个元素在集合中是否出现过，可以用哈希表
* O(n),但是因为涉及到删除操作，复杂度更高
*/
bool canConstruct(string ransomNote, string magazine) {
unordered_multiset<char> magazine_set(magazine.cbegin(), magazine.cend());
for(auto i : ransomNote){
auto itr = magazine_set.find(i);
if(itr != magazine_set.end()){
magazine_set.erase(itr);
} else
return false;
}
return true;
}
/*
* 类似于242，可以用数组来保存元素及其出现次数，更快,
* 还是哈希表思想
* O(n),但是没有删除操作
*/
bool canConstruct_hash(string ransomNote, string magazine) {
int record[26] = {0};
for(auto i : magazine){
record[i - 'a'] += 1;
}
for(auto i : ransomNote){
if(record[i - 'a'] > 0){
record[i - 'a'] -= 1;
} else
return false;
}
return true;
}
};
● 15. 三数之和
/*
* 15. 三数之和
中等
提示
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，
同时还满足 nums[i] + nums[j] + nums[k] == 0 。
请你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
*/
#include <algorithm>
class Solution_15 {
public:
/*
* 暴力解法可以找到三元组，但是不知道怎么去重
*
*关键是三元组内部可重复，但是多个三元组的元素不能重复，所以应该对三个元素进行去重操作
* 对第一个元素的去重重点在于由后一个元素判断前一个元素是否相同，如果对前一个元素进行去重，会使得类似{-1, -1, 2}这样的三元组被去掉
* 对双指针指向的两个元素去重关键是得在拿到第一个符合条件的三元组之后进行去重，负责类似于{0, 0, 0}这样的三元组会被去掉
*/
//去重失败
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;
if(i > 0){
nums[i] = nums[i - 1];
continue;
}
for(int j = i + 1; j < nums.size(); ++j){
if(j > 0){
nums[j] = nums[j - 1];
continue;
}
for(int k = j + 1; k < nums.size(); ++k){
if(k > 0){
nums[k] = nums[k - 1];
continue;
}
if(nums[i] + nums[j] + nums[k] == 0)
res.push_back(vector<int>{nums[i], nums[j], nums[k]});
}
}
}
return res;
}
vector<vector<int>> threeSum_double_points(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;
if (i > 0) {//去重,跟前一个比较，避免类似{-1, -1, 2}这样的三元组被去掉
if (nums[i] == nums[i - 1])
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while (left < right) {
if (nums[i] + nums[left] + nums[right] == 0) {
res.push_back(vector<int>{nums[i], nums[left], nums[right]});
while (left < right && nums[left] == nums[left + 1])//去重
left += 1;
while (left < right && nums[right] == nums[right - 1])//去重
right -= 1;
left += 1;
right -= 1;
} else if (nums[i] + nums[left] + nums[right] < 0) {
left += 1;
} else {
right -= 1;
}
}
}
return res;
}
};
● 18. 四数之和
/*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
你可以按 任意顺序 返回答案 。*/
class Solution_18 {
public:
/*
* 跟15相同的解法
*/
vector<vector<int>> fourSum(vector<int> &nums, int target) {
vector<vector<int>> res;
sort(nums.begin(), nums.end());
for (int i = 0; i < nums.size(); ++i) {
if(nums[i] > target)
return res;
if(i > 0 && nums[i] == nums[i - 1])
continue;
for (int j = i + 1; j < nums.size(); ++j) {
if(j > 1 && nums[j] == nums[j - 1])
continue;
int left = j + 1;
int right = nums.size() - 1;
while (left < right) {
if (nums[i] + nums[j] + nums[left] + nums[right] < target)
left += 1;
else if (nums[i] + nums[j] + nums[left] + nums[right] > target)
right -= 1;
else {
res.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
while (left < right && nums[left] == nums[left + 1])
left += 1;
while (left < right && nums[right] == nums[right - 1])
right -= 1;
left += 1;
right -= 1;
}
}
}
}
return res;
}
};