代码随想录算法训练营第七天 | LeetCode 454、383、15、18

---

前言

LeetCode题目：LeetCode 454、383、15、18
Takeaway：哈希表知识，map的使用，最重要的是双指针在哈希表中的使用，还有如何剪枝，如何去重，以及去重注意边界处理。

---

一、LeetCode 454

比较简单的一道题，就是用map来实现哈希表，将复杂度从O(n3)降低到O(n2)，前两数加和放进map里，再用O(n2)去找下一个数。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {

        // Key: Sum of A+B values  Value: Times
        unordered_map<int, int> sum_AB; 
        int ans = 0;

        // Sum of each nums1 and nums2
        for(int a : nums1){
            for(int b : nums2){
                sum_AB[a+b]++;
            }
        }

        // find c+d == 0-sumAB,就是把4数和变成3数和，这样复杂度不至于O(n^3),可以在O(n^2)内解决
        for(int c : nums3){
            for(int d : nums4){
                if(sum_AB.find(0-c-d) != sum_AB.end()){
                    ans += sum_AB[0-c-d];
                }
            }
        }

        return ans;
    }
};

---

二、LeetCode 383

和上一题一样用map存储，再在map里找需要的字母，也挺简单的，就是注意字母用一个少一个，用完自减就行。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> paper;

        //先把报纸里的每个单词都存进map里
        for(int i=0;i<magazine.size();i++){
            paper[magazine[i]]++;
        }

        //用一个少一个，找不到或者为0就说明拼不成，记得用了要-1
        for(int i=0;i<ransomNote.size();i++){
            if(paper.find(ransomNote[i]) == paper.end() || paper[ransomNote[i]] == 0 ){
                return false;
            }else{
                paper[ransomNote[i]]--;
            }
        }

        return true;
    }
};

---

三、LeetCode 15

我个人觉得很麻烦的一道题，先排序再双指针这点我想到了，因为我昨天的题就是用的这种方法。但是各种麻烦的去重让我最后还是去看了参考文章，去重还要注意各种边界处理。剪枝主要是：如果第一个数就比0大了，因为排序过，所以后面两数加一起，和肯定大于0了，直接剪掉。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());

        for(int i=0; i<nums.size(); i++){
            //第一个数就比0大了，因为排序过，所以三数加和肯定大于0了
            if(nums[i]>0){
                return res;
            }

            //去重要删i-1，因为i+1仍然可能用到
            if(i>0 && nums[i] == nums[i-1]){
                continue;
            }

            int left = i+1;
            int right = nums.size()-1;
            while(left<right){
                //小了，中间的值-left，需要右移来增大
                if(nums[i]+nums[left]+nums[right]<0){
                    left++;
                }else if(nums[i]+nums[left]+nums[right]>0){
                    right--;
                }else{
                    vector<int> elem = {nums[i], nums[left], nums[right]};
                    res.push_back(elem);

                    //去重要考虑的比较多，必须先判断left<right，不然++最后会越界
                    while(left<right && nums[left]==nums[left+1]){
                        left++;
                    }
                    while(left<right && nums[right]==nums[right-1]){
                        right--;
                    }
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
};

---

四、LeetCode 18

这题就是上面的LeetCode 15再嵌套一层，剪枝发生变化，别的变化不大，同理五数和，六数和就以此再套，每多一层，复杂度n右上+1，用了哈希就是将复杂度降低一次而已。

class Solution {
public:
    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++){
            //这里剪枝就和前面不一样了，因为之前是和为0，现在是和为target，target可以为负数
            if(nums[i]>target && nums[i]>=0){
                break;
            }
            //去重没什么变化
            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;
                }

                if(j>i+1 && nums[j] == nums[j-1]){
                    continue;
                }

                int left = j+1;
                int right = nums.size()-1;
                
                while(left<right){
                    if((long) nums[i]+nums[j]+nums[left]+nums[right]<target){
                        left++;
                    }else if((long) nums[i]+nums[j]+nums[left]+nums[right]>target){
                        right--;
                    }else{
                        vector<int> elem = {nums[i], nums[j], nums[left], nums[right]};
                        res.push_back(elem);
                    
                        while(left<right && nums[left] == nums[left+1]){
                            left++;
                        }
                        while(left<right && nums[right] == nums[right-1]){
                            right--;
                        }

                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
};

---

总结

今天的题主要还是哈希表的题，前两道比较简单，轻松搞定。后两道考验双指针+哈希表的使用，同时需要考虑剪枝和去重，以及去重过程中的大量边界处理，思路虽然有，但是实际做起来要复杂很多，各种剪枝，去重都要考虑的很仔细。