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

SuperYue37

已于 2023-01-18 21:53:38 修改

阅读量170

点赞数

分类专栏：代码随想录文章标签：算法哈希表 leetcode Powered by 金山文档

于 2023-01-18 21:35:59 首次发布

本文链接：https://blog.csdn.net/weixin_41275864/article/details/128730585

版权

代码随想录专栏收录该内容

10 篇文章 0 订阅

订阅专栏

LeetCode454.四数相加II

题目链接：https://leetcode.cn/problems/4sum-ii/

思路：想法是使用哈希表。定义一个哈希表unordered_map，遍历a数组与b数组，key存放a数组与b数组的元素之和，value存放a数组与b数组的元素之和出现的次数；再遍历c数组与d数组，在unordered_map中找0-（c+d），因为此时unordered_map中存放的是a+b，若是能找到0-（c+d）说明0-（c+d）= a+b成立，那么就把符合该条件的key对应的value统计出来，作为结果返回即可。

C++代码如下：

class Solution 
{
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) 
    {
        unordered_map<int, int> mp1;  //统计a和b数组的元素之和 与 出现次数
        for(int i = 0; i < nums1.size(); i++)       //key:a+b的和作为key    
        {                                           //value:a+b的和出现的次数作为value
            for(int j = 0; j < nums2.size(); j++)
            {
                mp1[nums1[i]+nums2[j]]++;
            }
        }
        int count = 0;  //统计a+b+c+d=0出现的次数
        for(int i = 0; i < nums3.size(); i++)
        {
            for(int j = 0; j < nums4.size(); j++)
            {
                if(mp1.find(0 - (nums3[i]+nums4[j])) != mp1.end())  //说明查找的key=0-(c+d)确实存在,而此时mp1中只有key=a+b，说明有0-(c+d)=(a+b)成立。
                {
                    count += mp1[0 - (nums3[i]+nums4[j])];  //即统计能满足0-(c+d)=(a+b)条件的次数
                }
            }
        }
        return count;
    }
};

LeetCode383.赎金信

题目链接：https://leetcode.cn/problems/ransom-note/

思路：这题其实就是想问ransomNote中的字符能不能被magazine中的字符覆盖完全。所以我使用哈希表unordered_map，key存储ransomNote里的各个字符，value存储各个字符出现的次数；接着遍历maganize，把各个字符(key)出现的次数(value)减去，再做判断：倘若ransomNote中的字符可以被magazine中的字符覆盖完全，那么unordered_map肯定小于等于0，倘若不能被完全覆盖，那么unordered_map中肯定存在大于0的value。

C++代码如下：

class Solution 
{
public:
    bool canConstruct(string ransomNote, string magazine) 
    {
        unordered_map<int, int> mp1;   //key存放字符，value存放出现次数
        for(int i = 0; i < ransomNote.size(); i++)
        {
            mp1[ransomNote[i]]++;   //统计不同的字符出现的次数
        }
        for(int i = 0; i < magazine.size(); i++)
        {
            mp1[magazine[i]]--;
        }
        for(unordered_map<int, int>::iterator it = mp1.begin(); it!=mp1.end(); it++) //只要有一个value>0，就是false；必须全部value<=0，才能是true。
        {
            if((*it).second > 0)
            {
                return false;
            }
        }
        return true;
    }
};

分析：其实在本题中，除了使用map，也可以使用数组，而且在本题的情况下，使用map的空间消耗要比数组大一些的。解题思路相同，只是采用的数据结构由map换成数组。

C++代码如下：

class Solution 
{
public:
    bool canConstruct(string ransomNote, string magazine) 
    {
        int record[26] = {0};
        //add
        if (ransomNote.size() > magazine.size()) 
				{
            return false;
        }
        for (int i = 0; i < magazine.length(); i++) 
				{
            // 通过recode数据记录 magazine里各个字符出现次数
            record[magazine[i]-'a'] ++;
        }
        for (int j = 0; j < ransomNote.length(); j++) 
				{
            // 遍历ransomNote，在record里对应的字符个数做--操作
            record[ransomNote[j]-'a']--;
            // 如果小于零说明ransomNote里出现的字符，magazine没有
            if(record[ransomNote[j]-'a'] < 0) 
						{
                return false;
            }
        }
        return true;
    }
};

LeetCode15.三数之和

题目链接：https://leetcode.cn/problems/3sum/

思路：使用双指针发来解决。

首先对数组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相遇为止。

注意的点：

a的去重

a，b，c对应的是nums[i]，nums[left]，nums[right]。a是nums里遍历的元素，理论上如果相邻前后重了，直接跳过去，但是我该如何判断，我是判断nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同呢？这两种写法是不一样的！如果写成以下形式：

if (nums[i] == nums[i + 1])  // 去重操作
{
    continue;
}

会把三元组中出现重复元素的情况忽略掉了。例如{-1，-1，2}这样的数据，nums[i]遍历到第一个-1时，判断到下一个也是-1，那么这组数据就pass掉了。**我们要做的是不能有重复的三元组，但是三元组内的元素是可以重复的！**所以写成以下形式：

if (i > 0 && nums[i] == nums[i - 1]) 
{
    continue;
}

这样写的意思就是使用nums[i]时，我们判断前一位是不是一样的元素，例如{-1，-1，2}这组数据，nums[i]遍历到第一个-1时，只要前面没有-1，那么{-1，-1，2}这组数据就可以存在结果集中。

b与c的去重

C++代码如下：

class Solution 
{
public:
    vector<vector<int>> threeSum(vector<int>& nums) 
    {
        vector<vector<int>> total_result;
        int left = 0;
        int right = 0;
        sort(nums.begin(), nums.end());   //从小到大排序

        if(nums[0] > 0)
        {
            return total_result;
        }

        for(int i = 0; i < nums.size() - 2; i++)
        {
            if(nums[i] > 0)
            {
                return total_result;
            }

            // 错误去重方法，将会漏掉-1,-1,2 这种情况
			/*
			if (nums[i] == nums[i + 1]) {
			continue;
			}
			*/
			// 对nums[i]去重。正确去重方法
			if (i > 0 && nums[i] == nums[i - 1])   //这么理解：符合这个if条件，continue后，又回到上面开始下一个for循环，即i++
			{             //从逻辑上也可以理解，在发现i和i+1相同以后，为了去重，就把i往右边移一位，即开始下一个for循环，即i++
				continue;
			}

            left = i+1;
            right = nums.size() - 1;
            while(left < right)
            {
                if(nums[i]+nums[left]+nums[right] < 0)
                {
                    left++;
                }
                else if(nums[i]+nums[left]+nums[right] > 0)
                {
                    right--;
                }
                else
                {
                    total_result.push_back(vector<int>{nums[i],nums[left],nums[right]});
                    //自己写的
                    left++;
                    while((nums[left] == nums[left-1])&&(left < right))//对nums[left]和nums[right]去重。
                    {
                        left++;
                    }
                    right--;
                    while((nums[right] == nums[right+1])&&(left <right))
                    {
                        right--;
                    }

                }
            }
        }
        return total_result;
    }
};

LeetCode18.四数之和

题目链接：https://leetcode.cn/problems/4sum/

思路：同样是使用双指针法，思路和上一题三数之和一样，只是多套一层for循环。

注意的点：

不要判断nums[k] > target就返回了，三数之和可以通过 nums[i] > 0就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

三数之和的双指针法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况。

C++代码如下：

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))  
            {
                //return result;
                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))
                {
                    //return result;
                    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)
                    {
                        left++;
                    }
                    else if((long)nums[k]+nums[i]+nums[left]+nums[right] > target)
                    {
                        right--;
                    }
                    else
                    {
                        result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
                        left++;
                        while((nums[left] == nums[left-1])&&(left<right))
                        {
                            left++;
                        }
                        right--;
                        while((nums[right] == nums[right+1])&&(left<right))
                        {
                            right--;
                        }
                    }
                }

            }

        }
        return result;
    }
};