代码随想录算法训练营第七天|454.四数相加II ● 383. 赎金信 ● 15. 三数之和 ● 18. 四数之和 ● 总结

力扣题目链接：454. 四数相加 II

因为这题是需要满足条件的元组个数，并且这题目是四个独立的数组，要求找到nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0。所以不需要考虑有重复的四个元素相加等于0的情况。

这种题目如果用暴力解法的话时间复杂度就太高了，四个for循环。

所以我们可以去想一点别的办法。我们前面做过一道两数之和的问题，可以使用哈希表的方法，只需要把关键码改为target-num[i]作为关键码。那么这个题目我们其实可以先使用一个二层for循环将nums1和nums2中各个元素之间的求出来，并且将其记录到哈希表中。计算数组之间的和的话，难免会出现重复的和，所以我们可以使用umap作为哈希表，key记录数组的和，value记录该和出现的次数。这样的话，等于是把所有的nums1[i]+nums2[j]记录了下来。

然后使用一个二层for循环去计算nums3和nums4的和，然后将0-(nums3[i]+nums4[j])作为关键码去我们的哈希表中查找相等的元素。如果能查找到，我们把哈希表中的value取出来，也就是记录次数，直到循环结束。最后返回我们记录的次数就好了。

本题代码如下：

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

这里需要注意的是，map插入元素的方式，map通常由4种插入元素的方式。

1、用insert函数插入pair数据

例如：

map<int,int> map1;
map1.insert(pair<int,int>(5,3));

2、用insert函数插入value_type数据

例如：

map<int, int> map1;
map1.insert(map<int, int>::value_type (5,3));

3.用make_pair

map1.insert(make_pair(5,3));

4.用数组方式插入数据

map<int, int> map1;
map1[1] = 5;
map1[2] = 3;

上面四种方法，用数组插入的方式有些特殊，它可以覆盖以前该key所对应的value，也就是说：如果当前存在该key，则覆盖该key的值，否则以该key新建一个key-value。

这题使用的就是数组的方式插入数据。

力扣题目链接：383. 赎金信

这个题目和判断有效字母异位词很相似，解法也基本上是一样的，可以用暴力解法也可以用哈希法。

用哈希法解起来非常方便。和有效字母异位词一样，因为题目给定的字母都是小写字母。所以可以创建一个长度为26的全零数组，然后记录magazine中a-z字母出现的次数。然后将该数组作为哈希表。

然后可以用一个for循环来遍历ransomNote中的各个字符，将其出现的次数在哈希表中减去即可。

最后用一个for循环遍历我们创建的哈希表，如果哈希表中有负数，说明ransomNote不能由magazine构成，如果没有则可以构成。具体过程如下：

代码：

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

因为是判断ransomNote是否能由magazine构成，所以可以进行依次剪枝操作，如果magazine的长度没有ransomNote长的话，说明magazine肯定不能由ransomNote构成。

力扣题目链接：15. 三数之和

这个题目可以使用哈希表去做，但是会非常麻烦，如果大家像了解哈希表的做法的话可以去

代码随想录。

我们使用双指针法处理这道题目。由于题目要求要返回所有不重复的三元组。所以这题有很多去重操作，还是比较棘手的。

使用双指针法的话，我们先要对数组进行排序。

然后我们可以使用一个for循环去遍历整个数组，然后用双指针法操作。大概过程就是，定义一个左指针left = i+1;，一个右指针right = nums.size()-1;，右指针指向最后一个元素。然后将nums[i]+nums[left]+nums[right]做判断，如果nums[i]+nums[left]+nums[right]>0，说明我们需要将右指针往左边移动，因为数组是排过序的，右指针最开始指向的元素是最大的，nums[i]+nums[left]+nums[right]>0了说明我们要将其中大的元素变小一点。如果nums[i]+nums[left]+nums[right]<0我们可以将左指针往右移动，因为左指针是等于i+1的i从0开始，nums[i]+nums[left]+nums[right]<0我们就需要将小的元素放大一点，也就是移动左指针。

如果nums[i]+nums[left]+nums[right]=0我们就记录三元组{nums[i],nums[left],nums[right]}，这就是双指针法的思路。但是由于题目要求返回所有不重复的三元组，所以本题还有很多去重操作。

首先可以进行一次剪枝操作，因为数组是排序后的，所以如果nums[i]>0的话nums[i]+nums[left]+nums[right]一定大于0，此时可以直接返回result。

然后就是对左右指针进行去重，去重操作大家可以看下图，讲不清楚感觉。

代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;
        for(int i =0;i<nums.size();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(right>left&&nums[left]==nums[left+1]) left++;
                    while(right>left&&nums[right]==nums[right-1]) right--;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

力扣题目链接：18. 四数之和

这题思路和三数之和是一样的，我们可以将四数看成三数，我们添加一层for循环，将前两数相加变成一个数。但同样的，需要进行两次剪枝操作和两次去重操作。

然后还有一个需要注意的点，就是上一题target是0，这一题target可能是负数，如果target是负数，那么我们的剪枝操作就不能单纯的nums[i]>target了，就比如nums[i]=-3>target = -4，如果这时候就直接跳出循环的话，会丢失很多结果。其他基本上与上一题思路一致，就是需要注意一下剪枝这里。

具体代码如下：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        for(int i =0;i<nums.size();i++)
        {
            if(nums[i]>target&&nums[i]>=0)
            {
                break;
            }
            if(i>0&&nums[i]==nums[i-1])
            {
                continue;
            }
            for(int j =i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]>target&&nums[i]+nums[j]>=0)
                {
                    break;
                }
                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) right--;
                    else if((long)nums[i]+nums[j]+nums[left]+nums[right]<target) left++;
                    else
                    {
                        result.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++;
                        left++ ;
                        right --;
                    }
                }
            } 
        }
        return result;
    }
};

哈希表总结：