今天时间比较紧迫，简单记录一下,三数之和、四数之和值得周末好好复习一下
第454题.四数相加II
这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目18. 四数之和，题目15.三数之和，还是简单了不少！ 本题解题步骤：
- 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
- 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
- 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
- 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
- 最后返回统计值 count 就可以了
// 时间复杂度: O(n^2)
// 空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
// 用于统计a+b+c+d = 0 出现的次数
int count = 0;
// key：a+b的值， value：该值出现的次数
unordered_map<int, int> map;
for(auto a : nums1) {
for(auto b : nums2) {
map[a + b]++;
}
}
for(auto c : nums3) {
for(auto d : nums4) {
if (map.find(0 - (c + d)) != map.end()) {
count += map.find(0 - (c + d))->second;
}
}
}
return count;
}
383. 赎金信
// 暴力解法
//时间复杂度: O(n^2)
//空间复杂度: O(1)
//erase操作也很耗时
bool canConstruct1(string ransomNote, string magazine) {
// magazine的遍历循环在外层，因为magazine的每个字符只能用一次
for(int i = 0;i < magazine.size(); ++i) {
for (int j = 0; j < ransomNote.size(); ++j) {
if (magazine[i] == ransomNote[j]) {
ransomNote.erase(ransomNote.begin() + j);
}
}
}
// 检查ransomNote是否拼完，并返回结果
if (ransomNote.length() == 0) {
return true;
}
else {
return false;
}
}
// 哈希表法 有界+寻找数值——>数组哈希
bool canConstruct2(string ransomNote, string magazine) {
int charList[26] = {0};
if (ransomNote.size() > magazine.size()) {
return false;
}
// 遍历magazine
for (int i = 0; i < magazine.size(); ++i) {
++charList[magazine[i] - 'a'];
}
// 遍历ransomNote
for (int i = 0; i < ransomNote.size(); ++i) {
if(charList[ransomNote[i] - 'a'] != 0) {
--charList[ransomNote[i] - 'a'];
}
else {
return false;
}
}
return true;
}
第15题. 三数之和
// 哈希表法 error超时了
// 时间复杂度: O(n^2)
// 空间复杂度: O(n)，额外的 set 开销
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) {
break;
}
// 三元组a去重
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
unordered_set<int> set;
for (int j = i + 1; j < nums.size(); ++j) {
// 三元组b去重
if (j > i+2
&& nums[j] == nums[j-1]
&& nums[j-1] == nums[j-2]
) {
continue;
}
int c = 0 - (nums[i] + nums[j]);
if (set.find(c) != set.end()) {
result.push_back({nums[i], nums[j], c});
set.erase(c); // 三元组c去重
} else {
set.insert(nums[j]);
}
}
}
return result;
}
vector<vector<int>> threeSum2(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;
}
// 错误去重a方法，将会漏掉-1,-1,2 这种情况
// 不应该向后查重，应该向前查重,否则会pass掉存在相同元素的三元组，注意是三元组去重，而不是三元组内部不能存在相同元素
/*
if (nums[i] == nums[i + 1]) {
continue;
}
*/
// 纠正的去重三元组a的方法
if (i > 0 && nums[i] == nums[i-1]) {
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while (right > left) {
// 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
/*
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) 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]});
// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
while (right > left && nums[right] == nums[right - 1]) {
right--;
}
while (right > left && nums[left] == nums[left + 1]) {
left++;
}
// 找到答案正常流程，双指针收缩
right--;
left++;
}
}
}
return result;
}
第18题. 四数之和
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
for (int i = 0; i < nums.size(); ++i) {
// 剪枝操作
if (nums[i] > target && nums[i] >= 0) {
break;
}
// 对nums[i]去重
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
for (int j = i + 1; j < nums.size(); ++j) {
// 剪枝操作
if (nums[i] + nums[j] > target && nums[i] + nums[j] >=0) {
break;
}
// 对nums[i]去重
if (j > i + 1 && nums[j] == nums[j - 1]) {
continue;
}
int left = j + 1;
int right = nums.size() - 1;
while (right > left) {
// nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
if ((long) nums[i] + nums[j] + nums[left] + nums[right] > target) {
right--;
// nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
} else if ((long) nums[i] + nums[j] + nums[left] + nums[right] < target) {
left++;
} else {
result.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
// 对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;
}
