力扣刷题Day7 | 哈希表Part02：454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和，总结

454.四数相加II

题目链接：https://leetcode.cn/problems/4sum-ii/description/
文章讲解/视频讲解：https://programmercarl.com/0454.%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0II.html

思路

将四个数组ABCD两两分为一组，分别求出每一组的两数之和，放到map中。因为数值大小未知，所以不能用数组，因为不仅需要记录数值大小，还要记录出现次数，所以需要有key和value两个参数，所以不能用set，故用map。
设置a+b为key，出现的次数为value，另一组c+d同理。通过将所有可能得a+b放到map中，再在遍历c+d的时候在map中寻找是否有target-(c+d)存在即可，存在就把对应的a+b的value值加上。

为什么要两两分组？

因为两两分组的时间复杂度是$n^2$，一三分组的时间复杂度是$n^3$。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        for(int a : nums1) {
            for(int b : nums2) {
                umap[a+b]++;
            }
        }

        int count = 0;

        for(int c : nums3) {
            for(int d : nums4) {
                if(umap.find(0 - (c + d)) != umap.end()) {
                    count += umap[0 - (c + d)];
                }
            }
        }

        return count;
    }
};

383. 赎金信

题目链接：https://leetcode.cn/problems/ransom-note/description/
文章讲解：https://programmercarl.com/0383.%E8%B5%8E%E9%87%91%E4%BF%A1.html
与字母异位词题目类似，用数组即可解决。

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

15. 三数之和

题目链接：https://leetcode.cn/problems/3sum/description/
文章讲解/视频讲解：https://programmercarl.com/0015.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.html

这道题目有很多细节，在写的时候遇到了很多问题。
首先是一开始忘记对nums进行排序了，为了后面求和、双指针的移动操作，应该在一开始就对数组进行排序，不然后续的指针移动就没有大小逻辑了。

其次是判断nums[i]是否大于0，大于0直接返回结果。这一句我一直不理解，直到我发现nums是从小到大排序且nums[i]是三元组的第一个数，一旦nums[i]>0，就说明left和right一定也大于0，那三数之和就肯定不会是0了，因此可以直接返回结果。

接着是去重操作，第一步是i的去重。

i代表的是每个三元组的第一个数字，而left和right则是用来寻找与nums[i]配对的另外两个数字。一旦i指向一个新的值，我们就开始寻找与之配对的left和right值，形成一个和为0的三元组。如果i指向的值与前一个相同，那么它会尝试形成相同的三元组，这是我们想要避免的。因此对i的去重必须放在其循环的开始处。

另外，由于i是三元组的第一个数，下标索引是从0开始的，所以在判断nums[i]和nums[i-1]的关系时，必须保证i是大于0的。

其次是left和right的去重。

因为我们去重的目的是为了避免出现重复的三元组，因此我们需要至少先保证收集了一个三元组，才能对后续相同的进行去重。因此对left和right的去重操作要在三数之和为0，且把这三个数存到结果集里面之后，在开始进行去重，也就是要放在else的大括号里面。

同时，去重的时候仍然要保持right>left，避免数组下标超出数组范围，比如数组为[0,0,0,0,0]，若没有这个条件，可能left会一直++到超过4，right会–到小于0，因为这里是while。

最后别忘了返回结果。

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) {
                return result;
            }

            if(i > 0 && nums[i] == nums[i - 1]) continue;  // 避免出现索引中出现<0的数

            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(right > left && nums[left] == nums[left + 1]) left++;
                        while(right > left && nums[right] == nums[right - 1]) right--;
                        
                        left++;
                        right--;
                }



            }

        }
        return result;
    }
};

18. 四数之和

题目链接：https://leetcode.cn/problems/4sum/description/
文章讲解/视频讲解：https://programmercarl.com/0018.%E5%9B%9B%E6%95%B0%E4%B9%8B%E5%92%8C.html

这题在上一题的基础上又增加了一个数，实际上就是多了一层for循环，不过剪枝和去重的操作也更多了，条件也变复杂了。

写代码的时候出现的一个问题是i的初值赋错了，我想当然的以为是从0开始，这明显是没有想清楚k和i的含义。k是四元组的第一个数，i是第二个数，接下来是两个指针。因此i的初始值应该是k+1才对。

另一个问题是四数相加时int类型发生了溢出，解决办法是将nums[k]转换为long类型，这样四数相加的时候结果也会被改成long类型，从而解决了溢出问题。

另外，还要注意break和continue的区别。break是跳出整个循环，continue是跳出本次循环。

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

        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(right > left) {
                    if((long) nums[k] + nums[i] + nums[left] + nums[right] > target) right--;
                    else if((long) nums[k] + nums[i] + nums[left] + nums[right] < target) left++;
                    else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});

                        // 去重
                        while(right > left && nums[left] == nums[left + 1]) left++;
                        while(right > left && nums[right] == nums[right - 1]) right--;

                        left++;
                        right--;
                    }
                }

            }
            
        }
        return result;
    }
};