day(007)哈希表练习

454.四数相加

思路:本题虽然是中等难度，但是感觉并不难，就是定义一个哈希表，一个哈希表用来存储数组1和数组2的和 和出现的次数，然后第二次循环遍历，在数组3和4中查找是否存在0-(num3[i]+num4[j]),若存在，累加上，这里要注意累加是0-(num3[i]+num4[j])这个数在哈希表中出现的次数。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> mp;
        int ncount=0;
        for(int i=0;i<nums1.size();i++){
            for(int j=0;j<nums2.size();j++){
                    mp[nums1[i]+nums2[j]]++;
            }
        }
         for(int i=0;i<nums3.size();i++){
            for(int j=0;j<nums4.size();j++){
                if(mp.find(0-(nums3[i]+nums4[j]))!=mp.end()){
                     ncount+=mp[0-(nums3[i]+nums4[j])];    
                }
            }
        }
        return ncount;
    }
};

383.赎金信

思路:和有效的字母异位词很相似，有点像数学中集合的概念，sm是big的子集，所以这道题我定义了哈希表用于存储sm中每个字符出现的次数，然后放到big字符数组中去遍历，如果sm中有元素big中没有，那么在第三次循环中就会存在没有减1的情况，就会返回FALSE。循环结束后没有进入到FALSE循环则返回TRUE。

class Solution {
public:
    bool canConstruct(string sm, string big) {
           unordered_map<char,int> mp;
           for(int i=0;i<sm.size();i++){
                 mp[sm[i]]++;
           }
           for(char c:big){
               if(mp.find(c)!=mp.end()){
                     mp[c]--;
               }
           }
           for(int i=0;i<sm.size();i++){
                if(mp[sm[i]]>=1){
                    return false;
                }
           }
           return true;
    }
};

15.三数之和

思路:哈希表法，这道题用哈希表法比较困难，因为要考虑到多种去重的情况，首先排序，判断第一个数若大于零代表该数组中不可能三个数相加等于0，因为最小值都大于0。然后第一种的去重情况，当前两种元素相等时，应确保不处理相同的值，然后是内层循环，通过j和c来找到满足nums[i] + nums[j] + nums[k] = 0的三元组，如果找到满足条件的就加入到二维向量数组中，然后将他从哈希表中删除，否则直接插入哈希表。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;
        for(int i=0;i<nums.size();i++){
              if(nums[i]>0){
                 break;
              }
              if(i>0&&nums[i]==nums[i-1]){
                continue;
              }
              unordered_set<int> st;
              for(int j=i+1;j<nums.size();j++){
                    if(j>i+2&&nums[j]==nums[j-1]&&
                        nums[j-1]==nums[j-2]){
                        continue;
                    }
                    int c=0-(nums[j]+nums[i]);
                    if(st.find(c)!=st.end()){
                        result.push_back({nums[i],nums[j],c});
                        st.erase(c);
                    }
                    else{
                        st.insert(nums[j]);
                    }
              }
        }
        return result;
    }
};

 思路2:双指针法

相较于哈希表法呢，思路要清晰一些，代码量要增多了，首先的思路和哈希表很相似，对取到的第一个数去重，然后定义左右指针，分别指向第二个元素和最后一个元素，故此时就需要判断nums[left]+nums[right]+nums[i]的和等于0即可，进入while循环，当左指针小于右指针的时候，如果当前的三个元素相加之和大于0，就让right--，否则就让left++也就是向前移动，当等于0时，添加到二维数组，判断当前的左右指针附近有无相同的元素若有则移动指针来去重，若没有，也要移动左右指针来指向下一个元素。

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){
                break;
            }
            if(i>0&&nums[i]==nums[i-1]){//先对第一个数去重
                 continue;
            }
            int left=i+1;
            int right=nums.size()-1;
            while(right>left){
                if((nums[left]+nums[right]+nums[i])>0)
                  right--;
                else if((nums[left]+nums[right]+nums[i])<0)
                   left++;
                else{
                    result.push_back(vector<int>{nums[left],nums[right],nums[i]});
                    while(right>left&&nums[right]==nums[right-1]) right--;
                    while(right>left&&nums[left]==nums[left+1])  left++;
                    right--;
                    left++;
                    }
                
            }
          return result;
    }
};

18.四数之和

思路:感觉是比较难的题目了，相对于三数之和来说，多加了一层for循环，也多加了一写去重操作，而且还要注意将nums[left]这个整数强制转换为长整型，不然会报错。

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