代码随想录算法训练营第七天|Leetcode 454.四数相加II、383.赎金信、15.三数之和、18.四数之和

文档讲解：代码随想录

视频讲解：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

---

第七天，做哈希表第二部分，继续坚持啊！

454.四数相加II

感受：在四个数组中分别找一个元素相加，如果得0就表示我们找到了一个目标数组。本题按照暴力解法我们需要进行四次遍历，太费时间了。因为题目性质我们不需要去重，那么用哈希表中的map进行解题。

思路： 定义一个unordered_map，key存放a和b两数之和，value存放两数和出现的次数。先对A和B的数组进行遍历，把他们对应的int和value存入map；再对C和D遍历，将A和B映射到其中来。通过判断0-（c+d）的值如果出现在map里，就把对应的value值统计出来并付给count。代码如下：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;
        for(int a : nums1){
            for(int b : nums2){
                map[a + b]++;
            }
        }
        int count = 0;
        for(int c : nums3){
            for(int d : nums4){
                if(map.find(0 - (c + d)) != map.end()){
                    count += map[0 - (c + d)];
                }
            }
        }
        return count;
    }
};

383.赎金信

感受：完了这题目练着练着感觉不对劲了呢，明明前几天才做过的类似的题，今天又不太会了...吐槽完毕，简单说下思路。

思路： 跟字母异位词差不多，只不过本题是要我们判断一个字符串能不能由另一个字符串里的字符构成，要注意的是字符不可重复使用，字符也全为小写。代码如下：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26] = {0};
        if(ransomNote.size() > magazine.size()) return false;
        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) return false;
        }
        return true;
    }
};

 15.三数之和

感受：看题目以为不难，整个做下来实则不简单，可以说是要考虑的细节还是不少的，本题哈希表和双指针均可，但因为要进行去重的操作，用双指针的思路要更简单一些。

思路：双指针法即定义两个指针分别指向数组左右两端，目的就是为了在判断三数之和与0作比较的时候为它们的结果不断调整和去重。若和大于0，那么右指针后移，将三数和调小一点；同样的如果和小与0，左指针前移将值调大一点。而如果正好等于0了，我们先将结果记录下来，之后再为两个数去重，去重的判断即如果右指针指向的数组元素与它指向的前一个元素相等，那么就后移一位，循环往复，直到没有重复或比左指针要小时退出循环。这是为 b去重，为 c去重也是同样的操作。

class Solution {
public:
    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) return result;
            //为 a去重
            if(i > 0 && 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) 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.四数之和

感受：就是上面那题的plus版本，因为虽然多加了一个数的操作，但实际要考虑的细节就会更多，三数时我们只需要进行一次剪枝和去重就好了，面对四数我们需要对遍历的i和k指针分别进行剪枝和去重，这就更考验我们对细节的把控了。（哪个干部经不起这样的考验？）

思路：总体逻辑与上面相似，这里我们重点理解一下多增加了一个数的情况下如何进行剪枝和去重操作。在本题中首先我们像上题一样进行一级剪枝：

if(nums[k] > target && nums[k] >= 0) break;

 再进行一级去重：

if(k > 0 && nums[k] == nums[k - 1]) continue;

这是在第一层k指针的循环中进行的。因为要求四数之和，所以再嵌套一层循环，我们确定为i的指针。在这其中，我们依然再次进行二级剪枝和去重：

if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) break;
if(i > k + 1 && nums[i] == nums[i - 1]) continue;

 剩余逻辑则与上题相同，我们结合代码提高对整题的理解：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int k = 0; k < nums.size(); k++){
            if(nums[k] > target && nums[k] >= 0) break;
            if(k > 0 && nums[k] == nums[k - 1]) continue;
            for(int i = k + 1; i < nums.size(); i++){
                if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) break;
                if(i > k + 1 && nums[i] == nums[i - 1]) continue;
                int left = i + 1;
                int right = nums.size() - 1;
                while(right > left){
                    if((long)nums[k] + nums[i] + nums[left] + nums[right] > target)right--;
                    else if((long)nums[k] + nums[i] + nums[left] + nums[right] < target) left++;
                    else{
                        result.push_back(vector<int>{nums[k], nums[i], 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;
    }
};

总结：总共耗时4h，已经慢慢感觉到了难度在上升，心态也经历了积极->平淡->受挫->平常 这样的一个变化，继续坚持。