代码随想录算法训练营第六天 - 哈希表2 || 454.四数相加II / 383.赎金信 / 15.三数之和 / 18.四数之和
454.四数相加II
文档讲解：代码随想录算法训练营
视频讲解：算法视频公开课
状态：思路自己想出来了，但代码没有实现出来
解题思路
首先如果使用暴力方法 ，也就是对数组nums1到nums2依次遍历，直到找到符合要求的组合，那么时间复杂度为O(n^4)。
如何能减少时间复杂度呢？
想到之间 242.有效字母异位词 的解法，我们可以遍历nums1和nums2，求出二者num1 + num2之和的组合，并记录出现的次数。
接着，我们再遍历nums3和nums4，现在我们的目标值是找到target = 0 - num3 - num4，因为题目要求num1 + num2 + num3 + num4 = 0，也就是要找num1 + num2 = - (num3 + num4)。然后在map里找target是否出现过，如果出现过，计数的变量count要加上target在map里的value值，即target在map里存储的次数。
代码实现：
cpp
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int,int> map;
// 遍历 nums1 和 nums2
for (int num1 : nums1) {
for (int num2 : nums2) {
map[num1 + num2] ++;
}
}
int count = 0;
// 遍历 nums3 和 nums4
for (int num3 : nums3) {
for (int num4 : nums4) {
int target = 0 - num3 - num4;
if (map.find(target) != map.end()) {
count += map[target];
}
}
}
return count;
}
};383.赎金信
文档讲解：代码随想录算法训练营
状态：自己完全做出来了
自己解答：
cpp
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
unordered_map<int,int> map;
// 遍历 magazine 字符串
for (int i = 0; i < magazine.size(); i++) {
map[magazine[i] - 'a'] ++;
}
// 遍历 ransomNote 字符串
for (int i = 0; i < ransomNote.size(); i++) {
map[ransomNote[i] - 'a'] --;
}
// 是否有 value < 0，如果有就不能构成
for (int i = 0; i < 26; i++) {
if (map[i] < 0) return false;
}
return true;
}
};代码随想录讲解
暴力做法
cpp
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
// 遍历 magazine 和 ransomNote
for (int i = 0; i < magazine.size(); i++) {
for (int j = 0; j < ransomNote.size(); j++) {
// 如果找到相同字符，就把这个字符从 ransomNote里删除
if (magazine[i] == ransomNote[j]) {
ransomNote.erase(ransomNote.begin() + j);
}
}
}
// 如果 ransomNote 里还有字符，那么就不构成
if (ransomNote.length() != 0) return false;
return true;
}
};哈希表
题目说只有小写字母，采用空间换取时间 的哈希策略，用一个长度为26的数组来记录magazine出现字母的次数。
为什么不采用map呢，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！
cpp
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int hash[26] = {};
for (int i = 0; i < magazine.size(); i++) {
hash[magazine[i] - 'a'] ++;
}
for (int i = 0; i < ransomNote.size(); i++) {
hash[ransomNote[i] - 'a'] --;
}
for (int i = 0; i < 26; i++) {
if (hash[i] < 0) return false;
}
return true;
}
};15.三数之和
文档讲解：代码随想录算法训练营
视频讲解：算法视频公开课
状态：自己有思路，在代码随想录基础上做优化
双指针
这道题要使用哈希表 的话，在去重操作中可能非常复杂，很难写全。
这道题应该使用双指针法 。
步骤一 ：先对数组进行从小到大排序；
步骤二 ：遍历数组，注意我们只需要遍历到数组的倒数第三个位置即可，因为我们需要 left 和 right，并且 i < left < right；
步骤三 ：去重。如果第一个数大于0即 nums[i] > 0，那么直接返回即可，不可能再有答案了。如果循环中，这个元素和上一个元素数值相等，那么直接跳过。
注意：我的语言描述是，这个元素和上一个元素数值相等，不是这个元素和下一个元素数值相等 。这是有区别的，比如nums = [-1, -1, 0, 1, 2]，当 i = 0 的时候，此时指向第一个 -1，如果判断这个元素与下一个元素，即 i = 1 的时候，此时指向的数也为 -1，那么就应该跳过 i = 0，明显是不正确的。正确应该是==该元素与上一个元素的值相等，跳过该元素。
步骤三 ：设 left = i + 1, right = n - 1，开始循环，循环条件是left < right，注意这里不能加上= ，当想到等时候就应该终止循环，而不是接着循环。
步骤四 ：当三数之和 > 0，那么让 right --；如果三数之和 < 0，那么就让 left ++；如果三数之和 = 0，就把结果放入到答案数组res中。
步骤五 ：放入res后，需要对left 和 right去重，如果 left < right，这个是前提，也必须在循环条件里，不写的话，可能造成死循环，比如数组nums = [0, 0, 0, 0, 0]，就会一直循环到头。对于right，如果下一个元素和该元素相等，那么就跳过元素；对于left，如果下一个元素和该元素相等，就跳过元素。
步骤六 ：找到符合要求的一组时，要让left 和 right收缩
cpp
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;
int n = nums.size();
// 对数组 nums 进行从小到大排序
sort(nums.begin(), nums.end());
for (int i = 0; i < n - 2; i ++) {
if (nums[i] > 0) return res;
if (i > 0 && nums[i] == nums[i - 1]) continue;
int left = i + 1;
int right = n - 1;
while (left < right) {
if (nums[i] + nums[left] + nums[right] > 0) right --;
else if (nums[i] + nums[left] + nums[right] < 0) left ++;
else {
res.push_back({nums[i], nums[left], nums[right]});
while (left < right && nums[left] == nums[left + 1]) left ++;
while (left < right && nums[right] == nums[right - 1]) right --;
// 找到解，收缩left 和 right
left ++;
right --;
}
}
}
return res;
}
};优化改进
可以加上几个判断：
如果nums的前三个元素之和 > 0，那么不可能再有解，直接break；
如果nums的后两个元素 + nums[i] < 0 ，那么可以跳过本次循环，left 和 right无论怎么移动也不能得到答案。
注意写i + 1，i + 2，for循环中一定写的是i < n - 2，否则会造成越界访问
cpp
if (nums[i] + nums[i + 1] + nums[i + 2] > 0) break;
if (nums[i] + nums[n - 2] + nums[n - 1] < 0) continue;除此之外，在找到答案的时候，对left 和 right的处理还可以再优化，代码更简洁，更易理解。
每次找到答案，我们先对left 和 right进行收缩操作，然后进行判重，也就是如果left < right，对于left，就是，该元素与上一个元素相等，就跳过，和步骤三一致。
cpp
for (left ++; left < right && nums[left] == nums[left - 1]; left ++);
for (right --; left < right && nums[right] == nums[right + 1]; right --);
cpp
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;
int n = nums.size();
sort(nums.begin(), nums.end());
for (int i = 0; i < n - 2; i ++) {
if (nums[i] > 0) return res;
if (nums[i] + nums[i + 1] + nums[i + 2] > 0) break;
if (nums[i] + nums[n - 2] + nums[n - 1] < 0) continue;
if (i > 0 && nums[i] == nums[i - 1]) continue;
int l = i + 1, r = n - 1;
while (l < r) {
if (nums[i] + nums[l] + nums[r] > 0) r --;
else if (nums[i] + nums[l] + nums[r] < 0) l ++;
else {
res.push_back({nums[i], nums[l], nums[r]});
for (l ++; l < r && nums[l] == nums[l - 1]; l ++);
for (r --; l < r && nums[r] == nums[r + 1]; r --);
}
}
}
return res;
}
};18.四数之和
文档讲解：代码随想录算法训练营
视频讲解：算法视频公开课
状态：自己仿照三数之和做出来了，调试了好几次，int换成long long，剪枝的位置不正确等等，最后还是AC了
自己的解答
cpp
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> res;
sort (nums.begin(), nums.end());
int n = nums.size();
for (int i = 0; i < n - 3; i ++) {
if (i > 0 && nums[i] == nums[i - 1]) continue;
if ((long long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break;
if ((long long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue;
for (int j = i + 1; j < n - 2; j ++) {
if (j > i + 1 && nums[j] == nums[j - 1]) continue;
int l = j + 1, r = n - 1;
while (l < r) {
if ((long long)nums[i] + nums[j] + nums[l] + nums[r] > target) r --;
else if ((long long)nums[i] + nums[j] + nums[l] + nums[r] < target) l ++;
else {
res.push_back({nums[i], nums[j], nums[l], nums[r]});
for (l ++; l < r && nums[l] == nums[l - 1]; l ++);
for (r --; l < r && nums[r] == nums[r + 1]; r --);
}
}
}
}
return res;
}
};系统讲解
本题和三数之和非常像，整体思路就是在三数之和的循环外，再套上一层循环即可。
这里要注意剪枝和去重。
首先对于一级剪枝操作，这里不能直接写nums[i] > target，直接就break 这是错误的，如果target < 0，num[i] < 0，负数加负数会变的越来越小，还是可能有解的，所以我们要加上条件。对于剪枝，同理还有如果前四个数之和 > target，直接break；nums[i]加上后三个数 < target，continue，注意，这里要转成long long类型才能过。
对于去重，和之前同理。
cpp
// 一级剪枝操作
if (nums[i] > target && nums[i] > 0 && target > 0) break;
if ((long long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break;
if ((long long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue;
// 一级去重
if (i > 0 && nums[i] == nums[i - 1]) continue;二级去重，就仿照一级去重来写，把nums[i] + nums[j]当成一个整体。
cpp
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> res;
int n = nums.size();
sort(nums.begin(), nums.end());
for (int i = 0; i < n - 3; i ++) {
// 一级剪枝，注意 long long
if (nums[i] > target && nums[i] > 0 && target > 0) break;
if ((long long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break;
if ((long long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue;
// 一级去重
if (i > 0 && nums[i] == nums[i - 1]) continue;
for (int j = i + 1; j < n - 2; j++) {
// 二级剪枝
if (nums[i] + nums[j] > target && nums[i] + nums[j] > 0 && target > 0) break;
if ((long long)nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) break;
if ((long long)nums[i] + nums[j] + nums[n - 2] + nums[n - 1] < target) continue;
// 二级去重
if (j > i + 1 && nums[j] == nums[j - 1]) continue;
// 下面同三数之和逻辑
int l = j + 1, r = n - 1;
while (l < r) {
if ((long long)nums[i] + nums[j] + nums[l] + nums[r] > target) r --;
else if ((long long)nums[i] + nums[j] + nums[l] + nums[r] < target) l ++;
else {
res.push_back({nums[i], nums[j], nums[l], nums[r]});
for (l ++; l < r && nums[l] == nums[l - 1]; l ++);
for (r --; l < r && nums[r] == nums[r + 1]; r --);
}
}
}
}
return res;
}
};