代码随想录算法打卡 Day7（哈希表）-四数相加 Ⅱ+ 赎金信 + 三数之和 + 四数之和

Leetcode 454-四数相加 Ⅱ

题目描述：

https://leetcode.cn/problems/4sum-ii/description/

解题思路

对数组 ABCD 两两进行求和，对于 AB 两数组，求和后将值保存在哈希结构中，然后对 CD 数组求和后，到哈希结构中寻找是否有出现符合与其相加为 0 的值，如果存在，则将 AB 中相加等于该值的个数加入到总体的计数中。

使用 unordered_map 的原因是在本题中不仅需要将相加的值记录下来，还需要记录该值出现的次数，因此 map 中的 key 是 AB 两数相加的值，value 是该值出现的次数。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;
        int count = 0;
        for (int a : nums1) {
            for (int b : nums2) {
                map[a + b]++;
            }
        }
        for (int c : nums3) {
            for (int d : nums4) {
                int target = -(c + d);
                if (map.find(target) != map.end()) {
                    count += map[target];
                }
            }
        }
        return count;
    }
};

Leetcode 383-赎金信

题目描述：

https://leetcode.cn/problems/ransom-note/description/

解题思路

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<int, int> map;
        for (int i = 0; i < ransomNote.size(); i++) {
            map[ransomNote[i]]++;
        }
        for (int i = 0; i < magazine.size(); i++) {
            map[magazine[i]]--;
        }
        for (int i = 0; i < ransomNote.size(); i++) {
            if (map[ransomNote[i]] > 0) {
                return false;
            }
        }
        return true;
    }
};

Leetcode 15-三数之和

题目描述：

https://leetcode.cn/problems/3sum/description/

解题思路

哈希法：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());//对nums进行排序，注意sort调用需要algorithm头文件
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > 0) {
                break;//如果nums容器中的最小的数都大于0，则三数之和不可能等于0
            }
            if (i > 0 && nums[i] == nums[i - 1]) {//对元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]) {//对三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({ nums[i],nums[j],c });
                    set.erase(c);//对三元组元素c去重
                }
                else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

双指针法：

在计算过程中要注意对i，left和right进行的去重操作，如对i去重时判断的是nums[i]==nums[i-1]而不是nums[i]==nums[i+1]，这是因为在for循环中每次遍历我们需要首先判断当前的i与上一次运行的i是否相同，如果相同则通过continue跳过后面的步骤

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)break;//剪枝操作
            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;
    }
};

Leetcode 18-四数之和

题目描述：

https://leetcode.cn/problems/4sum/description/

解题思路

四数之和的思路整体上与三数之和类似，需要在三数之和的基础上再嵌套一层循环，一些细节的地方需要注意。

注意在对k和i进行剪枝操作时，不可以直接按照三数之和的剪枝进行操作，这是因为四数之和求的target不为0，可能是负数，不能单纯的判断nums[k]>target进行剪枝，因为容器中可能还存在其他负数 同时需要注意，当对nums[k]+nums[i]+nums[left]+nums[right]求和时，可能存在溢出的风险，可以使用static_cast对int的sum进行转换，避免溢出的风险

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 && target > 0) break;//剪枝操作
            if (k > 0 && nums[k - 1] == nums[k]) continue;//去重操作
            for (int i = k + 1; i < nums.size(); i++) {
                if (nums[k] + nums[i] > target && target > 0) break;//二级剪枝
                if (i > k + 1 && nums[i - 1] == nums[i])continue;//二级去重
                int left = i + 1;
                int right = nums.size() - 1;
                while (left < right) {
                    long long sum = static_cast<long long>(nums[k]) + nums[i] + nums[left] + nums[right];
                    if (sum < target) left++;
                    else if (sum > target) right--;
                    else {
                        result.push_back(vector<int>{nums[k], 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;
    }
};