代码随想录算法训练营第六天 - 哈希表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里存储的次数。
代码实现：

class Solution {
public:int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {unordered_map<int,int> map;// 遍历 nums1 和 nums2for (int num1 : nums1) {for (int num2 : nums2) {map[num1 + num2] ++;}}int count = 0;// 遍历 nums3 和 nums4for (int num3 : nums3) {for (int num4 : nums4) {int target = 0 - num3 - num4;if (map.find(target) != map.end()) {count += map[target];}}}return count;}
};

383.赎金信

文档讲解：代码随想录算法训练营
状态：自己完全做出来了

自己解答：

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;}
};

代码随想录讲解

暴力做法

class Solution {
public:bool canConstruct(string ransomNote, string magazine) {// 遍历 magazine 和 ransomNotefor (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要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！

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收缩

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 和 rightleft ++;right --;}}}return res;}
};

优化改进

可以加上几个判断：
如果nums的前三个元素之和 > 0，那么不可能再有解，直接break；
如果nums的后两个元素 + nums[i] < 0 ，那么可以跳过本次循环，left 和 right无论怎么移动也不能得到答案。
注意写i + 1，i + 2，for循环中一定写的是i < n - 2，否则会造成越界访问

			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，就是，该元素与上一个元素相等，就跳过，和步骤三一致。

		for (left ++; left < right && nums[left] == nums[left - 1]; left ++);for (right --; left < right && nums[right] == nums[right + 1]; right --);

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了

自己的解答

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类型才能过。
对于去重，和之前同理。

	// 一级剪枝操作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]当成一个整体。

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 longif (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;}
};