Leedcode刷题 | Day7_哈希表02

 一、学习任务

• 454.四数相加II 代码随想录
• 383.赎金信
• 15. 三数之和
• 18. 四数之和
• 总结

二、具体题目

1.454四数相加II

        给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

        为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

重点：把一个O(n^4)复杂度算法拆分为两个O(n^2)的算法，利用map。

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

2.383赎金信

        给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

        (题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

重点：

• 可以按顺序映射（全是小写字母/大写字母），用数组开销小
• 类似242有效的字母异位词

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        for (int i = 0; i < magazine.length(); i++) {
            // 通过record数据记录 magazine里各个字符出现次数
            // magazine[i] - 'a'表示每个字母相对位置
            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; // 中间没return false证明杂志足够凑出赎金信
    }
};

3.15三数之和

        给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

        注意： 答案中不可以包含重复的三元组。

重点：去重

• 这道题用双指针法更容易写去重的边界条件
• 一定记住在每一次大循环时，至少找到一个result三元组才进行去重操作（有了第一个result才能说第二个和它重复！！！！！）
• 具体细节看代码注释：

class Solution {
public:
    vector> threeSum(vector& nums) {
        vector> result;
        sort(nums.begin(), nums.end());
        // 排序数组，便于后续操作
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i =  0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组
            // 直接返回结果
            if (nums[i] > 0) {
                return result;
            }
            // 因为i在最外层循环（第一位数），所以先考虑其去重
            // 第一轮比较i无需去重，所以i = 0时不考虑
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue; // i直接+1，进入下一个大循环
            }
            int left = i + 1;
            int right = nums.size() - 1;
            // b = nums[left], c = nums[right]不能是一个数字
            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{nums[i], nums[left], nums[right]});
                    // 至少在本轮i不变的第一个三元组找到后
                    // 才开始对b = nums[left], c = nums[right]去重（向中间去重）
                    while (left < right && nums[left] == nums[left + 1]) left++;
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    // 跳过重复的b c后，指向b c不重复的下一位
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
};

4.18四数之和

        题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

        注意：答案中不可以包含重复的四元组。

疑问：

• 为什么nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出？？？
• 为什么需要long long？？？
• 什么时候用break？为什么这里不能用return result？？？

错误之处：

1. 剪枝条件写成了nums[k] > target && target >= 0，而不是nums[k] > target && nums[k] >= 0
2. 为什么错误？？？？？

class Solution {
public:
    vector> fourSum(vector& nums, int target) {
        vector> result;
        // a = nums[k], b = nums[i], c = nums[left], d = nums[right]
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            // 对最外层k剪枝
            if (nums[k] > target && nums[k] >= 0) {
                break;
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue; // 跳过此轮k，开始下一轮
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // 对第二个循环i剪枝
                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 (left < right) {
                    // 为什么nums[k]+nums[i]+nums[left]+nums[right]> target 会溢出？？？
                    if ((long long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    }
                    else if ((long long) nums[k] + nums[i] + nums[left] + nums[right]  < target) {
                        left++;
                    }
                    else {
                        result.push_back(vector{nums[k], nums[i], nums[left], nums[right]});
                        // 至少在本轮i, k不变的第一个三元组找到后
                        // 才开始对c = nums[left], d = nums[right]去重（向中间去重）
                        while (left < right && nums[left] == nums[left + 1]) left++;
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        // 找到答案时，双指针同时收缩
                        // 跳过重复的c d后，指向c d不重复的下一位
                        left++;
                        right--;
                    }
                }
            } 
        }
        return result;
    }
};