代码随想录Day7 | 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

四数相加II

文档讲解：代码随想录
视频讲解： 学透哈希表，map使用有技巧！LeetCode：454.四数相加II
状态：×

4个独立的数组，找到的元组中又可以有重复的数字存在。当然可以使用4重循环来求解，时间复杂度就是$O(n^4)$。现在使用哈希表来求解，定义一个存储nums1和nums2的元素和的哈希表，并记录两数和的出现次数。再计算nums3和nums4的和，如果哈希表中有和的相反数，那表明存在四数相加等于0的情况，那么利用count变量把哈希表中存放的值取出来即可。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> check;
        int res_count = 0;
        //记录nums1[i]+nums2[j]的值
        for(int i = 0;i<nums1.size();i++)
        {
            for(int j=0;j<nums2.size();j++)
            {
                int sum = nums1[i]+nums2[j];
                auto target = check.find(sum);
                if(target != check.end())
                {
                    target->second++;
                }
                else
                {
                    check.insert(pair<int,int>(sum,1));
                }
            }
        }
        //计算nums3[i]+nums4[j]的值，检验check里面是否拥有
        for(int i = 0;i<nums3.size();i++)
        {
            for(int j=0;j<nums4.size();j++)
            {
                int sum = nums3[i]+nums4[j];
                auto target = check.find(0-sum);
                if(target != check.end())
                {
                    res_count += target->second;
                }
            }
        }       
        return res_count;
    }
};

时间复杂度$O(n^2)$

赎金信

文档讲解：代码随想录
视频讲解：
状态：√

本题直接利用数组构建哈希函数即可，因为同样英文字母只有26个。先利用数组记录mag中字母出现次数，因为mag的字母只能用一次，所以可以叠加记录。然后当在rans中找到了一个字母时，把数组中的对应值-1。因为是包含关系，所以数组中会出现大于0的值，而如果出现小于0的值说明不能构成。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        //利用数组记录字符的同时记录出现次数
        int check[26] = {0};
        for(int i = 0;i<magazine.size();i++)
        {
            check[magazine[i]-'a']++;
        }
        for(int i=0;i<ransomNote.size();i++)
        {
            check[ransomNote[i]-'a']--;
            if(check[ransomNote[i]-'a']<0)
            {
                return false;
            }
        }
        return true;
    }
};

时间复杂度：$O(n)$

三数之和

文档讲解：代码随想录
视频讲解： 梦破碎的地方！| LeetCode：15.三数之和
状态：×

返回的是数组，且元组中元素原始下标不相同，每个元组不相同。不能一味使用哈希表。map最多存储两个数据，其中有一个一定是和，另一个不足以使得结果避免重复。
利用双指针，左指针每次主循环比i大1，右指针每次主循环从尾部开始。在主循环对nums[i的重复性进行判断，从第二次主循环开始判断，即比较nums[i]与nums[i-1]是否相等，如果相等则跳过这次循环，这时为了避免结果中有重复的数组。
对i的重复性判断结束后，进入指针的移动操作，因为已经排好序，所以当和<0时left右移一位，当和>0时right左移一位。当相等时记录，并且两边指针同时收缩。
那么对nums[left]和nums[right]的重复性判断又应该放在哪里呢？

1. while循环开始，判断语句块前
   不能写在这里，因为此时还没有检测值是否=0，如果此时检测重复，那么会缺少情况。
2. else语句里
   在记录语句之后放入，当nums[left]与nums[left+1]相等或者nums[right]与nums[right-1]相等且left<right，那么就要对对应的left或者right进行值的修改。
   但应当放在两个指针同时收缩的语句之前。因为我们是对满足这次条件的指针进行判断收缩，而不是下一次还未进行判断的指针。

判断是否重复，都应当放在进行了一次操作之后，比如说对于控制主循环的i，对他的判断应当再一次循环过后，即i>1的情况下。而对于两个指针的判断，则应当是寻找到一个满足条件的数据之后。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int> >res;
        sort(nums.begin(),nums.end());
        for(int i = 0;i<nums.size();i++)
        {
            int left = i+1;
            int right = nums.size()-1;

            //去掉重复的nums[i]导致的重复的三元组
            if(i>0&&nums[i]==nums[i-1])
            {
                continue;
            }

            while(left<right)
            {
                if(nums[i]+nums[left]+nums[right] < 0)
                {
                    left++;
                }
                else if(nums[i]+nums[left]+nums[right] > 0)
                {
                    right--;
                }
                else
                {
                    res.push_back(vector<int>{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++;
                }
            }
        }
        return res;
    }
};

四数之和

文档讲解：代码随想录
视频讲解： 难在去重和剪枝！| LeetCode：18. 四数之和

状态

对比第一题
只有一个数组，返回的是一个二维数组，每个元组不能相同，每个元组中元素对应的下标不能相同
第一题中
四个数组，所以元组元素的下标也可以说是不相同的，不用考虑元组是否重复，我们是记录前两个数组的每个元素和，相同的和那么map的第二个值就+1，同样我们也是利用后两个的和去寻找匹配。不会去考虑元素是否一样。
所以这道题和上面那道题差不多。要注意去重判断的时机

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

                while(left<right)
                {
                    if((long)nums[i]+nums[j]+nums[left]+nums[right]<target)
                    {
                        left++;
                    }
                    else if((long)nums[i]+nums[j]+nums[left]+nums[right]>target)
                    {
                        right--;
                    }
                    else
                    {
                        res.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                        while(left<right && nums[right]==nums[right-1]) right--;
                        while(left<right&&nums[left]==nums[left+1]) left++;

                        right--;
                        left++;
                    }
                }
            }
        }
        return res;
    }
};

时间复杂度：$O(n^3)$