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

目录

Leetcode 454.四数相加II

Leetcode 383.赎金信

Leetcode 15.三数之和

Leetcode 18.四数之和

---

Leetcode 454.四数相加II

题目链接：Leetcode 454.四数相加II

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

思路：由于本题是四个数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况。使用哈希法很容易解决本题。

本题解题步骤：

（1）首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。

（2）遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。

（3）定义int变量count，用来统计 a+b+c+d = 0 出现的次数。

（4）在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。

（5）最后返回统计值 count 就可以了

本题的详细细节可以看这个视频：​​​学透哈希表，map使用有技巧！LeetCode：454.四数相加II

代码如下：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,
                     vector<int>& nums4) {
        unordered_map<int, int> map;
        for (int a : nums1) {
            for (int b : nums2) {
                map[a + b]++;
            }
        }
        int cnt = 0;
        for (int c : nums3) {
            for (int d : nums4) {
                if (map.find(-(c + d)) !=
                    map.end()) { //如果找到了就加上出现次数
                    cnt += map[-(c + d)];
                }
            }
        }
        return cnt;
    }
};

• 时间复杂度: O(n^2)
• 空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2

Leetcode 383.赎金信

题目链接：Leetcode 383.赎金信

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

思路：这道题和Leetcode 242.有效的字母异位词很像，都可以用哈希法来做，并且由于只有26个小写字母，数组模拟哈希表是效率最好的。

本题解题步骤：

（1）先通过record数据记录 magazine里各个字符出现次数

（2）再遍历ransomNote，在record里对应的字符个数做-1操作

代码如下：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        if (ransomNote.size() > magazine.size())
            return false;
        for (auto& c : magazine) {
            record[c - 'a']++;
        }
        for (auto& c : ransomNote) {
            record[c - 'a']--;
            // 如果小于零说明ransomNote里出现的字符，magazine没有
            if (record[c - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

Leetcode 15.三数之和

题目链接：Leetcode 15.三数之和

题目描述：

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

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

思路：本题看似和Leetcode 454.四数相加II很像，但本题是一个数组，并且不能有重复三元组。这就需要去重操作。本题仍可以使用哈希法，但双指针法更高效。

本题解题步骤：

（1）对数组排序。由于本题不需要返回数组元素下标，因此可以排序

（2）最外层循环用一个i指针从下标0开始遍历数组元素。

（3）内层用两个指针left=i+1和right=nums.size()-1。

（4）判断i+left+right和0的大小，如果前者大，让right--；如果后者大，让left++；相等时先将三个元素放入result中，接下来去重。去重不太理解的可以看这里：代码随想录

（5）left和right分别向内收缩一位。

代码如下：（双指针法）

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]) //对i访问的元素去重
                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]});
                    //对left和right访问的元素去重
                    while (left < right && nums[right] == nums[right - 1])
                        right--;
                    while (left < right && nums[left] == nums[left + 1])
                        left++;
                    //找到答案后left和right同时收缩
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
};

• 时间复杂度: O(n^2)
• 空间复杂度: O(1)

Leetcode 18.四数之和

题目链接：Leetcode 18.四数之和

题目描述：

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

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

思路：和上道题很像，就是多了一层循环，另外去重的细节需要注意一下。

首先说一个易错点：上道题我们判断nums[i]>0就直接return了，但本题写nums[k]>target就会有问题因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

代码如下：（双指针法）

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;
                //二级剪枝可以优化成这样
                /*因为只要 nums[k] + nums[i] > target，那么 nums[i]
                后面的数都是正数的话，就一定 不符合条件了。
                    if (nums[k] + nums[i] > target && nums[i] >= 0)
                        break;
                */
                //去重
                if (i > k + 1 && nums[i] == nums[i - 1])
                    continue;
                int left = i + 1;
                int 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 (left < right && nums[left] == nums[left + 1])
                            left++;
                        while (left < right && nums[right] == nums[right - 1])
                            right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};

• 时间复杂度: O(n^3)
• 空间复杂度: O(1)

总结：哈希表这一章节算是结束了，还剩几道拓展题等到周末复习之后完成。另外，连续写了一个星期博客之后现在越来越熟练了hhh。