代码随想录算法训练营第七天 |LeetCode454.四数相加 II、LeetCode383.赎金信、LeetCode15.三数之和、LeetCode18.四数之和-CSDN博客

本文链接：https://blog.csdn.net/qq_42498113/article/details/129210316

代码随想录算法训练营第七天 |LeetCode454.四数相加 II、LeetCode383.赎金信、LeetCode15.三数之和、LeetCode18.四数之和

2023年2月24日 补博客的同时再做一遍

454. 四数相加 II

题目链接:454. 四数相加 II

思路:

我们要遍历四个数组，遍历每个数组的时候我们关心的只是前面这些数组组成0-n[i]的组合数
所以我们要引入一个map记下之前遍历过的数组组成key的可能情况value
问题：
- 如果单独遍历每个数组，除第一轮插入，后面几轮既查找又插入，每轮中查到的value不能确定是否是本轮更新过的数据
- 所以这个map能一轮插，一轮读
看carl哥网站里的思路，该题应该把四个数组分成两轮二重循环，一轮插一轮读实现功能

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

代码:

class Solution
{
public:
    int fourSumCount(vector<int> &nums1, vector<int> &nums2, vector<int> &nums3, vector<int> &nums4)
    {
        std::unordered_map<int, int> my_map;
        for (auto n1 : nums1)
        {
            for (auto n2 : nums2)
            {
                my_map[n1 + n2]++;
            }
        }
        int count = 0;
        for (auto n3 : nums3)
        {
            for (auto n4 : nums4)
            {
                if (my_map.find(0 - n3 - n4) != my_map.end())
                {
                    count += my_map[0 - n3 - n4];
                }
            }
        }
        return count;
    }
};

总结:

没有想到将遍历四个数组应该有的四重循环分成两个二重循环
做题体验:哎哎（哈哈 > 嘿嘿 > 哎哎 > 嘤嘤）
时间:20min
一刷

383. 赎金信

题目链接:383. 赎金信

思路:

先记录下来magazine内没个字母出现的个数，用哈希表的思路实现
因为都是小写字母，这里使用数组来存储
再遍历ransomNote，在数组中对当前字母做减一操作，代表构成当前字符串之后magazine所剩的字符
如果数组值小于零，则返回false
遍历结束返回true

时间复杂度:O(n),空间复杂度O(n)

代码:

class Solution
{
public:
    bool canConstruct(string ransomNote, string magazine)
    {
        std::vector<int> v(26, 0);

        for (auto c : magazine)
        {
            ++v[c - 'a'];
        }
        for (auto c : ransomNote)
        {
            --v[c - 'a'];
            if (v[c - 'a'] < 0)
            {
                return false;
            }
        }
        return true;
    }
};

总结:

这道题比较简单，注意使用数组会在空间和时间复杂度上性能更优
做题体验:哈哈（哈哈 > 嘿嘿 > 哎哎 > 嘤嘤）
时间:10min
一刷

15. 三数之和

题目链接:15. 三数之和

思路:

自抛自扣：
- 为什么要对初始数组进行排序？
  - 排序之后的数组，在比较当前读取的三个值和0的关系后，可以有一个单向的扫描方向，利好时间复杂度
  - 相等的元素必定相邻，简化去重难度
- 怎么去重？
  - 首先三个数值都需要去重：
  - 但只需要判断两个，就是代码里的i和left(这是写博客的时候二刷的思路)
  - 如果i的后一位和当前位置的值相等，则后面满足nums[left] + left[right] = 0 - nums[i]的可能性已经列举出来了
  - 如果left的后一位和当前位置的值相等，当前循环里i是确定的，则继续找下去right肯定也是列举出来过的
  - right不需要判断，因为如果(nums[i] + nums[left] + nums[right]) == 0，left 和 right 同时移动，如果这一轮是重复结果，通过left就能判断出来
写得我自己都晕了哈哈

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

代码:

一刷

class Solution
{
public:
    vector<vector<int>> threeSum(vector<int> &nums)
    {
        vector<vector<int>> result_vec;
        std::sort(nums.begin(), nums.end());
        int length = nums.size();
        for (int i = 0; i < length - 2; ++i)
        {
            if (nums[i] > 0) //  不管另外两个数是什么结果都不会加出0
                return result_vec;
            if (i > 0 && nums[i] == nums[i - 1]) // 去重
            {
                continue;
            }
            int left = i + 1; // 左指针位置在i右侧以为
            int right = length - 1; // 右指针位置在数组尾端
            while (left < right)
            {
                if ((nums[i] + nums[left] + nums[right]) < 0) // 小了，左值针右移
                {
                    ++left; 
                }
                else if ((nums[i] + nums[left] + nums[right]) == 0)
                {
                    result_vec.emplace_back(vector<int>{nums[i], nums[left], nums[right]});
                    // 确定一个组合后，把left和right相邻的重复元素全跳过，二刷思路不同
                    while (left < right && nums[left] == nums[left + 1]) 
                        ++left;
                    while (left < right && nums[right] == nums[right - 1])
                        --right;
                    --right;
                    ++left;
                }
                else // 大了，左值针左移
                {
                    --right;
                }
            }
        }
        return result_vec;
    }
};

二刷

class Solution
{
public:
    vector<vector<int>> threeSum(vector<int> &nums)
    {
        vector<vector<int>> result;
        std::sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size() - 2; ++i)
        {
            if (nums[i] > 0)
                return result;
            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)
                {
                    // left指向的值和上一轮一样，那这次判断肯定是重复的
                    if (left - i > 1 && nums[left] == nums[left - 1])
                    {
                        ++left;
                        --right;
                        continue;
                    }
                    result.emplace_back(vector<int>{nums[i], nums[left], nums[right]});
                    ++left;
                    --right;
                }
                else if ((nums[i] + nums[left] + nums[right]) < 0)
                {
                    ++left;
                }
                else
                {
                    --right;
                }
            }
        }
        return result;
    }
};

总结:

好题啊，算是双指针的灵活运用了
做题体验:嘤嘤（哈哈 > 嘿嘿 > 哎哎 > 嘤嘤）
时间:……
一刷

18. 四数之和

题目链接:18. 四数之和

思路:

三数之和的变形题，多一个数，就得多加一重循环
双指针的价值就体现在，可以节约一重循环
对于三重循环来说，合适的剪枝可以节约时间开销
另外去重的操作和三数相加类似

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

代码:

class Solution
{
public:
    vector<vector<int>> fourSum(vector<int> &nums, int target)
    {
        std::sort(nums.begin(), nums.end());
        vector<vector<int>> result;
        for (int i = 0; i < nums.size(); ++i)
        {
            // 剪枝
            if (nums[i] > target && nums[i] > 0)
                break;
            // 去重
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            for (int j = i + 1; j < nums.size(); ++j)
            {
                // 剪枝
                if (nums[i] + nums[j] > target && nums[i] + nums[j] > 0)
                    break;
                // 去重
                if (j - i > 1 && nums[j] == nums[j - 1])
                    continue;
                int left = j + 1;
                int right = nums.size() - 1;
                while (left < right)
                {
                    if (((int64_t)nums[i] + nums[j] + nums[left] + nums[right]) < target)
                    {
                        ++left;
                    }
                    else if (((int64_t)nums[i] + nums[j] + nums[left] + nums[right]) == target)
                    {
                        result.emplace_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        // 去重
                        while (left < right && nums[left] == nums[left + 1])
                            left++;
                        while (left < right && nums[right] == nums[right - 1])
                            right--;
                        ++left;
                        --right;
                    }
                    else
                    {
                        --right;
                    }
                }
            }
        }
        return result;
    }
};