454. 四数相加 II+383. 赎金信+15. 三数之和+18. 四数之和

清蒸GAMMA

已于 2023-03-21 15:12:55 修改

阅读量1k

点赞数

分类专栏： leetcode刷题记录文章标签： leetcode 算法 c++ Powered by 金山文档

于 2023-03-20 23:52:41 首次发布

本文链接：https://blog.csdn.net/Wang_Dechang/article/details/129673707

版权

leetcode刷题记录专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章提供了几个关于寻找数组中特定数字组合的C++代码实现，包括四数相加II、赎金信、三数之和以及四数之和的问题。这些问题都涉及到使用哈希表、排序和双指针等算法来解决。在解题过程中，作者强调了理解问题本质和有效利用数据结构的重要性。

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

454. 四数相加 II

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        std::multimap <int, int> num1_num2;
        std::multimap <int, int> num3_num4;
        int k = 0;
        for (int i = 0 ; i < nums1.size() ; i++)
        {
            for(int j = 0 ; j < nums2.size() ; j++)
            {
                if(num1_num2.find(nums1[i] + nums2[j]) == num1_num2.end())
                {
                    num1_num2.insert(pair <int , int>((nums1[i] + nums2[j]), 1));
                }
                else 
                {
                    auto it = num1_num2.find(nums1[i] + nums2[j]);
                    it -> second = it -> second + 1;
                }
            }
        }
        for (int i = 0 ; i < nums3.size() ; i++)
        {
            for(int j = 0 ; j < nums4.size() ; j++)
            {
                if(num1_num2.find( - nums3[i] - nums4[j]) != num1_num2.end())
                {
                    k = k + num1_num2.find( - nums3[i] - nums4[j]) -> second;
                }
            }
        }
        return k;
    }
};

这道题错了好多次，主要原因是看见提示说用map, 但是自己没思考为什么用map，结果在存A+B的时候没存该值有几个相等的值，以后应该注意写不出来就直接看解析，别死扣，浪费时间。

383. 赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        std::map<char, int> a;
        for( int i = 0 ; i < magazine.length() ; i++)
        {
            auto it = a.find(magazine[i]);
            if(  it != a.end() )
            {
                (it -> second)++;
            }
            else
            {
                a.insert(pair <char , int > (magazine[i] , 1));
            }
        }
        for( int i = 0 ; i < ransomNote.length() ; i++)
        {
            auto it = a.find(ransomNote[i]);
            if(it == a.end() || it -> second == 0)
            {
                return 0;
            }
            else
                (it -> second)--;
        }
        return 1;
    }
};

没什么好说的，小题

15. 三数之和

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) 
    {
        vector<vector<int>> res;
        vector <int> temp;
        int left = 0 ;
        int right = nums.size() - 1;
        sort(nums.begin(), nums.end());
        for( int i = 0 ; i < nums.size() ; i++)
        {
            if(i > 0 && nums[i] == nums[i - 1])
            {
                continue;
            }
            left = i + 1;
            
            right = nums.size() - 1;
            while(left < right)
            {
                if(left > i + 1 && nums[left] == nums[left - 1])
                {
                    left++;
                    continue;
                }
                if(nums[i] + nums[left] + nums[right] > 0)
                {
                    right = right - 1;
                }
                else if(nums[i] + nums[left] + nums[right] < 0)
                {
                    left++;
                }
                else
                {
                    temp = {nums[i] , nums[left] , nums[right]};
                    res.push_back(temp);
                    left++;
                    right--;
                }
            }

        }
        return res;
    }
};

这道题的第一个陷阱是视频中归纳为哈希表，使得我一开始就想套用哈希表，后来发现不行。

去重是第二个陷阱，此题的去重不是单纯的不要同一个元素，而是说，结果得到的元素不能有重复，思路应该是，先把重复的放在一起，然后滤除重复的。因此，应该先排序，而后通过双指针的方法，如果碰到重复的元素应该直接进入下次循环。

18. 四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        int third = 0 ;
        int len = nums.size();
        int forth = len - 1;
        if(nums.size() < 4)
        {
            return res;
        }
        sort(nums.begin() , nums.end());
        if(nums[0] > target && nums[0] > 0)
        {
            return res;
        }
        for(int i = 0 ; i < (nums.size() - 3) ; i++)
        {
            if(i !=  0 && nums[i] == nums[i - 1])
            {
                continue;
            }
            for(int j = i + 1 ; j < (nums.size() - 2) ; j++)
            {
                if( j != i + 1 && nums[j] == nums[j - 1])
                {
                    continue;
                }
                third = j + 1;
                forth = nums.size() - 1;
                while(third < forth)
                {
                    if( third != j+1 && nums[third] == nums[third - 1])
                    {
                        third++;
                        continue;
                    }
                    if(forth != nums.size() - 1 && nums[forth] == nums[forth + 1])
                    {
                        forth--;
                        continue;
                    }
                    if((long)nums[i] + nums[j] + nums[third] + nums[forth] < target)
                    {
                        third++;
                    }
                    else if((long)nums[i] + nums[j] + nums[third] + nums[forth] > target)
                    {
                        forth--;
                    }
                    else
                    {
                    res.push_back({nums[i] , nums[j] , nums[third] , nums[forth]});
                    third++;
                    forth--;
                    }
                }
            }
        }
        return res;
    }
};

思路和三数之和一样，就是加了一层循环，要注意和是long int类型