Day07｜哈希表02: 454.四数相加II、383赎金信、15.三数之和、18.四数之和

454.四数之和

leetcode链接：力扣题目链接(opens new window)

视频链接：学透哈希表，map使用有技巧！LeetCode：454.四数相加II (opens new window)

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

这题只需输出符合条件的数对数量，也不需要去重，二刷就有思路了，使用一个hashtable先遍历数组1，2，保存sum和其出现的次数，再用二重循环遍历数组3，4，一个一个查表，这样将复杂度从暴力的O($n^4$)转化为O($n^2$)。

我的代码：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int>sum;
        int res = 0;
        for(int num1 : nums1){//保存两者中的和，key是和，value是次数
            for(int num2 : nums2){
                sum[num1 + num2]++;
            }
        }
        for(int num3 : nums3){
            for(int num4 : nums4){
                auto iter = sum.find(0 - (num3 + num4));
                if(iter != sum.end()){
                    res += iter->second;
                }
            }
        }
        return res;
    }
};

这里的iter->second就是value，first是key。

标准题解：

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

383.赎金信

和有效的字母异位词差不多，没什么好说的，也适用数组建hashtable：

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

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

标准题解:

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        //add
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        for (int i = 0; i < magazine.length(); i++) {
            // 通过record数据记录 magazine里各个字符出现次数
            record[magazine[i]-'a'] ++;
        }
        for (int j = 0; j < ransomNote.length(); j++) {
            // 遍历ransomNote，在record里对应的字符个数做--操作
            record[ransomNote[j]-'a']--;
            // 如果小于零说明ransomNote里出现的字符，magazine没有
            if(record[ransomNote[j]-'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

注意有一处不同，这里是验证ransomNote的时候就可以验证是否小于0。

15.三数之和、18.四数之和

这两题的意思差不多，只不过4Sum在3Sum基础上多了一个枚举循环。题解用的是双指针，实际上，切入可先用2Sum的双指针法：

vector<vector<int>> twoSum(vector<int>& nums,int start, int target){
        sort(nums.begin(),nums.end());
        vector<vector<int>> res;
        int lo = start, hi= nums.size() - 1;
        while(lo < hi){
            int left = nums[lo];
            int right = nums[hi];
            if(left + right > target){
                while(lo < hi && nums[hi] == right){
                    hi--;
                }
            }else if (left + right < target){
                while(lo < hi && nums[lo] == left){
                    lo++;
                }
            }else{
                res.push_back({left,right});
                while(lo < hi && nums[lo] == left){
                    lo++;
                }
                while(lo < hi && nums[hi] == right){
                    hi--;
                }
            }
        }
        return res;

此方法源自labuladong的博客。后来看代码随想录的时候发现可能这里的:

 while(lo < hi && nums[hi] == right){
                    hi--;
                }

对数的去重也是不必要的，因为就算前后的hi对应的值相同了，hi还是要–的，这也解答了我的疑问：为什么嵌套了while循环中的时间复杂度仍然是O(N)（总复杂度是O(NlogN)，因为还有排序）。但是对于=target情况下的去重是必要的。

（我后来想想上面的一步还是有必要的，相当于后面3sum时候的跳过nums[i]的操作）。

于是3Sum就变成了枚举一个for加target = 0 - （nums[i])的2Sum问题：

    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> res;
        //首先对nums数组进行排序，使用双指针法。
        for(int i = 0; i < nums.size(); i++){
            vector<vector<int>> res1 = twoSum(nums, i + 1, 0 - nums[i]);
            for (vector<int>& res11 : res1) {
                res11.push_back(nums[i]);
                res.push_back(res11);
            }
            while (i < nums.size() - 1 && nums[i] == nums[i + 1]) i++;//跳过相同的nums[i]
        }
        return res;
    }

4sum同理，可复用3Sum，多了一层循环，因此可以总结出nSum问题的递归写法：

 vector<vector<int>> nSumTarget(
            vector<int>& nums, int n, int start, int target) {
        target = (long)target;
        int sz = nums.size();
        vector<vector<int>> res;
        // 至少是 2Sum，且数组大小不应该小于 n
        if (n < 2 || sz < n) return res;
        // 2Sum 是 base case
        if (n == 2) {
            // 双指针那一套操作
            int lo = start, hi = sz - 1;
            while (lo < hi) {
                long sum = (long)(nums[lo] + nums[hi]);
                int left = nums[lo], right = nums[hi];
                if (sum < target) {
                    while (lo < hi && nums[lo] == left) lo++;
                } else if (sum > target) {
                    while (lo < hi && nums[hi] == right) hi--;
                } else {
                    res.push_back({left, right});
                    while (lo < hi && nums[lo] == left) lo++;
                    while (lo < hi && nums[hi] == right) hi--;
                }
            }
        } else {
            // n > 2 时，递归计算 (n-1)Sum 的结果
            for (int i = start; i < sz; i++) {
                vector<vector<int>>
                        sub = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for (vector<int>& arr : sub) {
                    // (n-1)Sum 加上 nums[i] 就是 nSum
                    arr.push_back(nums[i]);
                    res.push_back(arr);
                }
                while (i < sz - 1 && nums[i] == nums[i + 1]) i++;
            }
        }
        return res;
    }
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        return nSumTarget(nums,4,0,target);
    }

（但我用这个代码没AC，应该是sum太大溢出的问题，不知道哪里需要类型转换，暂时还没有改好，但试了几个testcase都是对的）。

更新 ：我发现不止我一个人遇到了上面的问题，而且很巧的是我们遇到的都是这个testcase：

	Line 37: Char 69: runtime error: signed integer overflow: -1294967296 - 1000000000 cannot be represented in type 'int' (solution.cpp)
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior prog_joined.cpp:46:69
	测试用例:[1000000000,1000000000,1000000000,1000000000]
			-294967296

这是官方新加的一个十分巧妙的edge case，产生的原因是会在循环到n == 2即运算two sum时负数target会不断相减并反向溢出来到20亿整，会刚好与后两位和相等并返回，但负的target怎么可能从只有正整数的数组中获得呢，所以很有必要加上官方答案中的平均数判断来避免此问题。
(最简单的改法是把nSumTarget函数的target改成long）

最后贴一下标准题解：

3Sum：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> 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;
            }
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            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--;
                else if (nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
};

4Sum:

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; // 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // 2级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }

                // 对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left) {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    } 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]});
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        // 找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }

            }
        }
        return result;
    }
};

总结

今天的题目与其说是哈希表章节但实际上关于hashtable的题都不太难，主要是双指针的用法，掌握了nSum的通用求法，但剪枝仍然是难点。另外以后的刷题上午就解决，不然熬夜到晚上效率大不如前。。。