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

本文链接：https://blog.csdn.net/Midlight_moon/article/details/129149586

本文详细探讨了LeetCode上的四道经典算法题，包括四数相加II（第454题）、赎金信（第383题）、三数之和（第15题）和四数之和（第18题）。文章通过分析思路、常见困难和解决方案，分享了利用哈希表和双指针等方法来优化算法的时间复杂度，以及在编程实践中的注意事项和收获。

摘要由CSDN通过智能技术生成

第454题.四数相加II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

题目链接

视频链接

思路

无

看完代码随想录之后的思路：

避免使用4个连续的for，使得时间复杂度剧增。使用两个分开的双层for循环，溶蚀用哈希map表来进行高效查询

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

遇到的困难：

unordered_map定义时一定要加上数据类型<int,int>
定义数据一定要令其等于0，否则会出现不可知的报错！int count=0
第二个循环中，寻找的是0-（c+d），此时已经没有a、b了，count+-也是与c、d有关，不能弄反了！！

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

题目链接

思路

打算使用集合哈希

看完代码随想录之后的思路：

因为只有小写字母，所以使用数组哈希就可以

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.size();i++)
        {
            record[magazine[i]-'a']++;
        }
        for(int j=0;j<ransomNote.size();j++)
        {
            record[ransomNote[j]-'a']--;
            if(record[ransomNote[j]-'a']<0)return false;
        }
        return true;
    }
};

暴力解法：

// 时间复杂度: O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        for (int i = 0; i < magazine.length(); i++) {
            for (int j = 0; j < ransomNote.length(); j++) {
                // 在ransomNote中找到和magazine相同的字符
                if (magazine[i] == ransomNote[j]) {
                    ransomNote.erase(ransomNote.begin() + j); // 因为需要找到对应元素的地址/索引，所以不能直接使用j
                    break;
                }
            }
        }
        // 如果ransomNote为空，则说明magazine的字符可以组成ransomNote
        if (ransomNote.length() == 0) {
            return true;
        }
        return false;
    }
};

遇到的困难：

两个数组相等是不用返回false，存在刚好相等的情况。

收获：

暴力解法中的收获：

在C++11及以后的标准中，auto关键字可以用来推断变量的类型。当使用auto定义变量时，编译器会根据变量初始化表达式的类型推断出该变量的类型。

auto x = 42;     // 推断x的类型为int
auto d = 3.14;   // 推断d的类型为double
auto s = "hello"; // 推断s的类型为const char*

std::vector是C++中的一个动态数组，支持erase()函数，可以使用该函数从向量中删除指定位置的元素。下面是一个使用erase()函数删除向量元素的例子：（find返回的是一个索引/地址）

#include <iostream>
#include <vector>

int main() {
  std::vector<int> vec = {1, 2, 3, 4, 5};

  auto it = std::find(vec.begin(), vec.end(), 3);
  if (it != vec.end()) {
    vec.erase(it);  // 删除找到的元素
  }

  for (int i = 0; i < vec.size(); i++) {
    std::cout << vec[i] << " ";  // 输出：1 2 4 5
  }

  return 0;
}

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

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

题目链接

视频链接

思路：

无

看完代码随想录之后的思路：

哈希map卡边界条件太麻烦，使用双指针法。

先排序，然后开始从左往右，移动首位i，每个i中移动左右两个指针，找合适的组合。

先算算数组中第i位是否大于0，否则直接结束；

去重a

当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()-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)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;
    }
};

遇到的困难：

最后压栈的是一维向量，所有合起来是二维向量，不要压错类型

在找到合适的变量后，一定要记得把指针向后移动。去重只是把指针移到相同的位置上，结尾继续移动才能指向下一个不相同的。

收获：

定义一个二维向量：

vector<vector<int>> result;

sort用于对指定范围内的元素进行排序。它通常用于对向量、数组或列表等容器进行排序，可以按升序或降序排列元素。参数为（第一个元素，最后一个元素）

重点：

对b和c的去重，不能放在前面两个判断和是否等于0的if else中，否则{000}就被pass掉了，一定是要取得一个结果之后再进行去重

关注a、bc的去重语句

第18题. 四数之和

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

注意：

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

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

题目链接

视频链接

思路：

想用双指针，但是不知道第三个指针该指向何处

看完代码随想录之后的思路：

前面两个基础数用两层for循环，最后的两个数用双指针。此外，任意的n数之和都可以用这个方法，双指针可以将时间复杂度降一次。

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[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;
    }
};

遇到的困难：

k和i在for循环的中间语句中，不能为了省事把后面的数据个数减去，否则遇到不足量的数组，会出现错误。
剪枝操作的结果应该是break，而不是return result。在i的for循环中，i、k和大于target后，下一个k还可能会有其他的i适配，不能直接return。
i、k剪枝的两个条件中，可以取一个等号，但不能同时都取等
双指针的剪枝要注意，加上long，否则会溢出
双指针的去重，注意要把left<right写上，否则出现相同的情况，会左右交叉