代码随想录训练营第38期Day7

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

今天是跟着代码随想录刷题的第七天，今天是第一次让我觉得难得有点应接不暇，三个数之和和四个数之和都没能独立写出来，很多情况都没考虑到，现在把几道题都看懂了，争取二刷的时候能独立写出来。今天主要学了以下内容：454.四数相加II 、383. 赎金信 、15. 三数之和 、18. 四数之和 。
链接地址： 454.四数相加II、383. 赎金信 、15. 三数之和 、18. 四数之和

---

一、454.四数相加II

思路：这道题的思路就是把四个变成2+2，把前两个的和全部放进哈希表里，如果有多个就值以此加1代表次数就好，然后把后两个的和全部得到依次取个反在前面哈希表里查找，如果有一样的就加上这个键对应的值，这样就可以得到有多少个元祖相加等于0
自己想的笨方法：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
    std::unordered_map <int,int> map;
    int i;
    int j;
    for(i=0;i<nums1.size();i++)
    {
        for(j=0;j<nums2.size();j++)
        {
            if(map.find(nums1[i]+nums2[j])!=map.end())
            {
                map[nums1[i]+nums2[j]]++;
            }
            else {map.insert(pair<int,int>(nums1[i]+nums2[j],1));}
        }
    }
    int count=0;
    for(i=0;i<nums3.size();i++)
    {
        for(j=0;j<nums4.size();j++)
        {
            int target=-(nums3[i]+nums4[j]);
            if(map.find(target)!=map.end())
            {
                count+=map[target];
            }
        }
    }
    return count;
    }
};

标准代码：

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int> umap; //key:a+b的数值，value:a+b数值出现的次数
        // 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
        for (int a : A) {
            for (int b : B) {
                umap[a + b]++;
            }
        }
        int count = 0; // 统计a+b+c+d = 0 出现的次数
        // 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
        for (int c : C) {
            for (int d : D) {
                if (umap.find(0 - (c + d)) != umap.end()) {
                    count += umap[0 - (c + d)];
                }
            }
        }
        return count;
    }
};

标准代码的前两个循环包括内部结构写的方式可以学习一下：

for (int a : A) {
            for (int b : B) {
                umap[a + b]++;
            }
        }

直接完成遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。

二、383. 赎金信

思路：和有效字母异位词差不多，第一个放到数组里，第二个看有没有，如果把第一个字符串导致数组的变化更正过来，就返回true，不能就返回false。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
    int hash[26]={0};
    for(int i=0;i<ransomNote.size();i++)
    {
        hash[ransomNote[i]-'a']++;
    }
    for(int j=0;j<magazine.size();j++)
    {
        if(hash[magazine[j]-'a']!=0)
        {
            hash[magazine[j]-'a']--;   
        }
    }
    for(int z=0;z<26;z++)
    {
        if(hash[z]!=0)
        {
            return false;
        }
    }
    return true;
    }
};

暴力解法：

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); // ransomNote删除这个字符
                    break;
                }
            }
        }
        // 如果ransomNote为空，则说明magazine的字符可以组成ransomNote
        if (ransomNote.length() == 0) {
            return true;
        }
        return false;
    }
};

这里注意字符串的删除操作：ransomNote.erase(ransomNote.begin() + j);从字符串的开头数第j个删除，后面的break会跳出内层循环，但是不会跳出外层循环，所以内层循环会重新执行，所以逻辑没问题。

三、15. 三数之和

思路：就是先要对数组进行排序，然后把开头的一个指针设为i，首先判断，第一位是不是都大于0，不然白玩，判断完还要判断i右移以后的位置是否和左边一样，不然也白玩（这个没太理解），另外一个叫left在i右边一位，right在数组末尾，然后i每到一个位置，先求这原始位置三个数的和，大了就right右移，小了就left左移，正好等于0的话先放进元祖里，还需要判断一下去重的问题，如果left的右边一位还是这个，则左边白移一次，不能放进元祖，同理，right的左边一位还是这个，一样不能放，直到left的右边一位不是这个，right的左边一位也不是这个才行，这时候把left右移一次，right左移一次，继续循环。
代码：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
    sort(nums.begin(),nums.end());
    int i;
    for(i=0;i<nums.size();i++)
    {   
        int left=i+1;
        int right=nums.size()-1;
        if(nums[0]>0)
        {
            break;
        }
        if(i>0 && nums[i]==nums[i-1])
        {
            continue;
        }
        while(left<right)
        {
            if(nums[i]+nums[left]+nums[right]==0)
            {
                result.push_back({nums[i],nums[left],nums[right]});
                while(left<right&&nums[right]==nums[right-1]) right--;
                while(left<right&&nums[left]==nums[left+1]) left++;
                // 找到答案时，双指针同时收缩
                right--;
                left++;
            }
            else if(nums[i]+nums[left]+nums[right]>0)
            {
                right--;
            }
            else if(nums[i]+nums[left]+nums[right]<0)
            {
                left++;
            }
            
        }
    }
    return result;    
    }
};

四、18. 四数之和

思路：多一个循环嵌套，但是要注意剪枝。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
    vector<vector<int>> result;
    sort(nums.begin(),nums.end());
    int i,k;
    for(k=0;k<nums.size();k++)
    {   
        if(nums[k]>target&&nums[k]>=0)
        {
            break;
        }
        if(k>0&&nums[k]==nums[k-1])
        {
            break;
        }
    for(i=k+1;i<nums.size();i++)
    {   
        int left=i+1;
        int right=nums.size()-1;
        if(nums[k]+nums[i]>target&&nums[k]+nums[i]>=0)
        {
            break;
        }
        if(i>0 && nums[i]==nums[i-1])
        {
            continue;
        }
        while(left<right)
        {
            if(nums[k]+nums[i]+nums[left]+nums[right]==target)
            {
                result.push_back({nums[k],nums[i],nums[left],nums[right]});
                while(left<right&&nums[right]==nums[right-1]) right--;
                while(left<right&&nums[left]==nums[left+1]) left++;
                // 找到答案时，双指针同时收缩
                right--;
                left++;
            }
            else if(nums[k]+nums[i]+nums[left]+nums[right]>target)
            {
                right--;
            }
            else if(nums[k]+nums[i]+nums[left]+nums[right]<target)
            {
                left++;
            }
            
        }
    }
    }
    return result;    
    }
};