代码随想录算法训练营第七天|454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和

454.四数相加II

题目

解题思路

（之前纠结点在于感觉时间复杂度过高，但是没想到其他办法）

• 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
• 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
• 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
• 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
• 最后返回统计值 count 就可以了

代码

#include <unordered_map>
#include <vector>

using namespace std;

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        //key:a+b的数值，value:a+b数值出现的次数
        unordered_map<int, int> sum;

        // 记录 num1 和 num2 每个元素的和,value存出现的次数
        for (int i: nums1) {
            for (int j: nums2) {
                sum[i + j] += 1;
            }
        }

        // 记录和为 0 的次数
        int count = 0;
        for (int i: nums3) {
            for (int j: nums4) {
                // 查找 num3 和 num4 每个元素和的相反数，这样如果相等则符合题意
                if (sum.find(-(i + j)) != sum.end()) {
                    count += sum[-(i + j)];
                }
            }
        }
        return count;
    }
};

383. 赎金信

题目

解题思路

• 和昨天的题是一样的思路，使用map，key记录字符，value记录出现的次数
• 然后和另一个字符串对比
• 代码随想录用的是数组，数组空间占用小（可以练习哈希表，所以用hashmap）

代码

#include <unordered_map>
#include <string>

using namespace std;

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> record;

        // 如果 ransomNote 大，则不符合题意，直接返回false
        if (ransomNote.size() > magazine.size()) return false;

        // 遍历magazine，key为每个字符，value为字符出现的个数
        for (char c: magazine) {
            record[c] += 1;
        }

        for (char c: ransomNote) {
            // 字符每出现一次，value减1
            record[c] -= 1;
            // 如果有字符的个数小于0，说明有字符没出现过
            if (record[c] < 0) {
                return false;
            }
        }
        return true;
    }
};

15. 三数之和

题目

解题思路

（全靠讲解）
拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

时间复杂度：O(n^2)。

其实上图中有很多重复的操作，在i 和 left 选择好几次-1就可以看出都是重复的。

代码

#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    vector<vector<int>> threeSum(vector<int> &nums) {
        vector<vector<int>> result;
        int left, right;
        // 从小到大排序
        sort(nums.begin(), nums.end());
        //k < nums.size() - 2是为了保证后面还能存在两个数字
        for (int i = 0; i < nums.size() - 2; ++i) {
            // 如果nums中第一个元素，即最小值都大于0，那三个元素的和肯定大于0
            if (nums[0] > 0) return {};

            // 对结果集去重，如果出现重复，那必然是：后一次循环是前一次循环的子集。
            // {-4,-1,-1,0,1,2} 当i=2，即指向第二个-1时，其结果集{-1,0,1｝已经在i指向第一个-1的时候遍历过了
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            left = i + 1;
            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]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    // 循环最后，指针同时收缩
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

18. 四数之和

题目

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

解题思路

• 和三数之和很相似，不多赘述了。
• 需要注意的是，target可能小于0，负数越加越小
• 三数之和是一个循环，四数之和是再套一次循环

代码

#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    vector<vector<int>> fourSum(vector<int> &nums, int target) {
        vector<vector<int>> result;
        int left, right;
        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] == nums[k - 1]) 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] == nums[i - 1]) continue;
                left = i + 1;
                right = nums.size() - 1;
                while (left < right) {
                    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[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

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