第七天 | 454.四数相加 383.赎金信 15.三数之和 18.四数之和

题目：454.四数相加

思路：

1.用map：因为既需要key来存加和，又需要value来统计该加和出现了多少次。

遍历a, b数组时，将a+b放进map的key，同时统计出现的次数放进value

2.一开始的疑惑：为什么四个数组要两两分组算加和，然后存进map？为什么不能一三分组？

这是从时间复杂度的考虑，两两分为n的平方，一三分为n的三次方。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;//key:a+b的数值，value:a+b数值出现的次数
        //遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
        
        for(int a : nums1){
            for(int b : nums2){
                map[a + b]++;
            }
        }
        int count = 0;//统计次数
        //再遍历nums3和nums4数组，如果找到-(c + d)在map中出现过，就把map中key对应的value也就是出现次数统计出来。
        for(int c : nums3){
            for(int d : nums4){
                if(map.find(-(c + d)) != map.end()){
                    count += map[-(c + d)];
                }
            }
        }
        return count;
    }
};

需要思考：

1。遇到这种题为什么会想到用哈希表：先预处理前两个数组，再在后两个数组里去查。

2.用哈希法的时候应该选用什么样的哈希结构

3.key放什么，value放什么。

题目：383.赎金信

较简单，和有效的字母异位词一模一样

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

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

优解：双指针。

        先进行排序。

        a遍历每一个数，b，c分别从a+1，nums.size() - 1往中间夹，记录满足条件的三元组，每有一个满足条件的三元组出现，就要进行对应的去重处理。

        和大于0则right左移，和小于0则left右移。

难点：去重细节

特别注意注释中标注的错误去重方法

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;          //为什么这里不需要给result分配内存？
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > 0) return result;        //若排序后第一个数已经大于0，则与其他两数的加和一定大于0
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法           
            
            if(i > 0 && nums[i] == nums[i - 1]) continue;          //对a去重
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left){
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                if(nums[i] + nums[left] + nums[right] > 0) right--;   //和小于0，通过增大b来使和增大
                else if(nums[i] + nums[left] + nums[right] < 0) left++;  //和大于0，通过缩小b来使和缩小
                else{
                    //找到了目标三元组，将其存入数组
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    while(right > left && nums[left] == nums[left + 1]) left++;        //对b去重
                    while(right > left && nums[right] == nums[right - 1]) right--;     //对c去重
                    //最开始在这两个去重的while循环里没有写right>left,想想会导致什么后果？
                    left++;
                    right--;
                }
            }
            
        }
        return result;

    }
};

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

较三数之和而言，差异在于剪枝和去重

在两次剪枝时，收三树之和的影响，容易犯惯性的错，认为两个数相加就会更大，但没有考虑负数的情况。ex: -4, -1, 0, 0, target = -5。所以在第一级剪枝时有差异。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int a = 0; a < nums.size() - 3; a++){
            //第一级剪枝
            if(nums[a] > target && nums[a] > 0 && target > 0) break;  //只有在target为正数的情况下才能如此进行剪枝操作
            //对a去重
            if(a > 0 && nums[a] == nums[a - 1]) continue;    //一定是判断nums[a] == nums[a - 1]而不是nums[a] == nums[a + 1]
            for(int b = a + 1; b < nums.size() - 2; b++){
                //二级剪枝
                if(nums[a] + nums[b] > target && nums[a] + nums[b] > 0 && target > 0) break;
                //对b去重
                if(b > a + 1 && nums[b] == nums[b - 1]) continue;

                int c = b + 1;
                int d = nums.size() - 1;
                while(c < d){
                    if((long)nums[a] + nums[b] + nums[c] + nums[d] < target) c++;
                    else if((long)nums[a] + nums[b] + nums[c] + nums[d] > target) d--;
                    else{
                        result.push_back(vector<int>{nums[a], nums[b], nums[c], nums[d]});
                        while(c < d && nums[c] == nums[c + 1]) c++;         //对c去重
                        while(c < d && nums[d] == nums[d - 1]) d--;         //对d去重
                        //****这两个while循环里c < d这个条件真的非常容易错啊，三叔之和错了，四树枝和这里又忘写了
                        c++;
                        d--;
                    }
                }
            }
        }
        return result;
    }
};