【Day6】代码随想录二刷之Chapter32——哈希表part3

今天把哈希表剩下的几个题目刷完，开冲！！！

今日任务：

• 454.四数相加
• 383.赎金信
• 三数之和
• 四叔之和

题目一：454.四数相加

Leetcode题目：【454.四数相加】

非常暴力的解法，结果自然也是超出时间限制了，n^4的时间复杂度，但是之前刷的题目的思路没有想起来：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int result = 0;
        for(int i = 0; i<nums1.size(); i++){
            for(int j = 0; j<nums2.size(); j++){
                for(int m = 0; m<nums3.size(); m++){
                    for(int n = 0; n<nums4.size(); n++){
                        if(nums1[i] + nums2[j] + nums3[m] + nums4[n] == 0){
                            result++;
                        }
                    }
                }
            }
        }
        return result;
    }
};

看了卡哥的解法，时间复杂度直接将为n^2，整体的解题思路为：
（1）把A数组和B数组看成一个整体，然后计算a+b的值，并且统计其出现的次数（key，value键值对这样就可以定义出来了）；
（2）遍历C、D数组，查找C、D数组中key值是否有0-（c+d）的情况，如果有那就把前面的次数也加起来。

代码的时间复杂度降为了n^2。

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

题目二：383.赎金信

Leetcode题目：【383.赎金信】

只要涉及到判断字母个数的这种问题，都是可以考虑数组形式的哈希法，非常简单，大体思路为：
（1）统计子字符串中字母出现的次数；
（2）另外一个也继续统计字母出现的次数；
（3）只要某一个减到0了，就可以立刻返回了。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int letter[26] = {0};
        for(int i = 0; i<ransomNote.size(); i++){
            letter[ransomNote[i] - 'a']++;
        }

        for(int i = 0; i<magazine.size(); i++){
            letter[magazine[i] - 'a']--;
        }

        for(int i = 0; i<26; i++){
            if(letter[i] > 0){
                return false;
            }
        }

        return true;

    }
};

题目三：15.三数之和（双指针法）

Leetcode题目：【15.三数之和】

使用双指针法的思路很巧妙，具体过程如下：

（1）首先定义个3个索引，left是从i+1开始，right是从尾部开始。假设a = nums[i]，b = nums[left]，c = nums[right]
找到a + b + c = 0；
（2）如果 a + b + c > 0，说明和有点大，需要right小一点；如果 a + b + c < 0，说明和有点小，left需要向右移动。直到left和right可以相遇为止。

关于去重的操作这个很难想，此处需要注意下：

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++){
           // 最小值大于0，那一定不存在
           if(nums[0] > 0){
               return result;
           }
           // 对i进行去重
           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]});
                   while(left<right && nums[left] == nums[left + 1]) left++;
                   while(left<right && nums[right] == nums[right - 1]) right--;
                   left++;
                   right--;
               }
           }
       }
        return result;
    }
};

题目四：18.四数之和（双指针法）

Leetcode题目：【18.四数之和】

这个题目和三数之和的区别在于多了一层，但是也是很简单，就是在i后面再多加一个j，然后也做去重处理就好了。
与此同时，题目还做了剪枝处理（可以不做），它的思路就是：如果排好序的数组，前面的一个>target了，同时它本身还是正数，在这种情况下，就可以做剪枝处理。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for(int i = 0; i<nums.size(); i++){
            
            // 保证正数情况下，如果第一个还是大于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((long)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{
                        result.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        while(left<right && nums[left] == nums[left+1])   left++;
                        while(left<right && nums[right] == nums[right-1]) right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;

    }
};