关键内容：

454.本题的思路在于分组，因为是几个不同数组的元素相加，所以将一部分数组分为一组，剩下的一组，第一组放入map，与第二组比较，进行后续操作；因此，本题为4个数组，实则3个之类的也可。同时注意map的key与val是什么，此题key是元素值，val是出现的次数（方便日后count的计算）

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> exm;
        for (int a : nums1)
        {
            for (int b : nums2)
            {
                exm[a+b]++;     //首先要清楚key和val分别是什么，这里val是次数，初始化0
            }
        }
        int count=0;
        for (int c:nums3)
        {
            for (int d: nums4)
            {
                if (exm.find(0-c-d)!=exm.end())
                {
                    count+=exm[0-c-d];        //注意不要写成count+=1。次数未必只有1；
                }
            }
        }
        return count;
    }
}

383.此题快速判断得出需要用哈希表做，可用数组或是map，而map维护成本高，数据更大时比数组慢得多。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26]={0};
        for (int i=0;i<ransomNote.length();i++)
        {
            hash[ransomNote[i]-'a']+=1;
        }
        for (int i=0;i<magazine.length();i++)
        {
            hash[magazine[i]-'a']-=1;
        }
        for (int i=0;i<26;i++)
        {
            if(hash[i]>0)
            {
                return false;
            }
        }
        return true;
    }
};

15.三数之和，本题用哈希表（set）或是用双指针都可以做，但哈希表细节处理繁琐的多（主要由于三元组不可以重复，去重操作繁琐），所以用双指针更佳，而最需要注意的问题便是三个点的去重方式和时机

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;
        int left;
        int right;
        if(nums[0]==0 && nums[1]==0 && nums[2]==0)
        {
            result.push_back(vector<int>{0,0,0});
            return result;
        }
        for (int i=0;i<nums.size();i++)
        {
            /*if(nums[i]==nums[i+1])    //第一点去重，这是开始时错误的方式，若三元组同时包含nums【i】，【i+1】，便会错过。
            {
                continue;
            }*/
            if(i>0 && nums[i]==nums[i-1])   //这样可以
            {
                continue;
            }
            left=i+1;
            right=nums.size()-1;
            while(left<right )
            {
               /* if (nums[left]==nums[left+1]) //第二，第三点开始的错误去重方式，这样主要的错因在于若合适的right与left相等且相邻，就会错过，所以要先存储，再去重
                {
                    left+=1;
                    continue;
                }
                if (nums[right]==nums[right-1])
                {
                    right-=1;
                    continue;
                }*/
                if(nums[i]+nums[left]+nums[right]==0)
                {
                    vector<int> p;
                    p.push_back(nums[i]);
                    p.push_back(nums[left]);
                    p.push_back(nums[right]);
                    //if(result.find(p)==result.end())
                    result.push_back(p);
                   while(right>left && nums[right]==nums[right-1])
                    {
                        right--;
                    }
                    while(right>left && nums[left]==nums[left+1])
                    {
                        left++;
                    }
                    left+=1;
                    right-=1;
                    continue;
                }
                if(nums[i]+nums[left]+nums[right]<0)
                {
                    left+=1;
                    continue;
                }
                if(nums[i]+nums[left]+nums[right]>0)
                {
                    right-=1;
                    continue;
                }
            }
        }
        return result;
    }
};

总结：
要熟练哈希表的使用情况和操作；
去重要考虑清楚，往往需要借助几个特殊的例子。