代码随想录算法训练营第6天|哈希表part02

• 454.四数相加II

• 383. 赎金信

• 15. 三数之和

• 18. 四数之和

• 总结

详细布置

454.四数相加II

建议：本题是 使用map 巧妙解决的问题，好好体会一下 哈希法 如何提高程序执行效率，降低时间复杂度，当然使用哈希法 会提高空间复杂度，但一般来说我们都是舍空间换时间， 工业开发也是这样。

本题解题步骤：

1. 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。因为要统计数量，所以存储的是次数。
2. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
3. 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
4. 再遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
5. 最后返回统计值 count 就可以了

题目链接/文章讲解/视频讲解：代码随想录

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

在学习的过程中，还是了解了很多使用方法，如在插入 map12 时，直接使用 map12[k]++ 来增加计数，这样如果 k 不存在，unordered_map 会自动初始化 k 对应的值为 0，然后再自增。

 for (int i : nums1) 

    for (int j : nums2) 

                int k = i + j;

对于这种方式访问的是元素，所以不要写成int k=nums[i]+nums[j]；直接i+j；

383. 赎金信

建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {

        int record[26] = {0};
        for (int i = 0; i < magazine.length(); i++) {
            record[magazine[i]-'a'] ++;
        }
        for (int j = 0; j < ransomNote.length(); j++) {
            record[ransomNote[j]-'a']--;
            if(record[ransomNote[j]-'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

确实和

q题目链接/文章讲解：代码随想录

if (ransomNote.size() > magazine.size()) {

            return false;

加上这句代码确实挺好的，长度不符合，直接返回，和昨天的代码很相似。

15. 三数之和

力扣题目链接(opens new window)

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

建议：本题虽然和 两数之和 很像，也能用哈希法，但用哈希法会很麻烦，双指针法才是正解，可以先看视频理解一下 双指针法的思路，文章中讲解的，没问题 哈希法很麻烦。

两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。

把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。

双指针法更为巧妙，分为i和left,right两个指针。i右移，用来遍历。left和right用来筛选。但是这题最大的问题还是判断重复的。因此在遍历的时候，要考虑和前面的i是否相同，相同就跳过。

result.push_back(vector<int>{nums[i], nums[left], nums[right]});学到了如何把 一组数压到二维数组里。使用vector<int>{nums[i], nums[left], nums[right]}先定义一个函数，然后再.pushback();

 while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

另外别忘了去重，有可能左右指针移动的 时候还是会遇到，第一次写的时候，就忘了left和right 去重。

题目链接/文章讲解/视频讲解：代码随想录

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

                 
                }

            }    

        }       
        return result;
        }
};

18. 四数之和

建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。

15.三数之和 (opens new window)的双指针解法是一层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的情况，三数之和的时间复杂度是O(n^2)，四数之和的时间复杂度是O(n^3) 。

所以四数之和的方法也就是三数之和的方法再套一层循环即可。

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

学会了三数和，四数和还是比较简单的。但是最大的问题还是搞懂里面的弯弯绕绕，还是有很多坑的。

题目链接/文章讲解/视频讲解：代码随想录

补充：不另外补充变量，交换两个变量的值，用三次异或，进行交换运算a ^= b; b ^= a; a ^= b;假设初始时，a 和 b 的值分别是 a0 和 b0。

第一次异或这一步后，此时：

• a = a0 ^ b0，b = b0

第二次异或于 a 已经是 a0 ^ b0，所以这一步后，b 的值变为 b0 ^ (a0 ^ b0)。根据异或操作的性质 (x ^ y) ^ y = x，我们可以简化为：

b = b0 ^ (a0 ^ b0) = a0第二次异或于 a 已经是 a0 ^ b0，所以这一步后，b 的值变为 b0 ^ (a0 ^ b0)。

根据异或操作的性质 (x ^ y) ^ y = x，我们可以简化为：b = b0 ^ (a0 ^ b0) = a0。此时：

a = a0 ^ b0，b = a0

第三次异或：

由于此时 b 是 a0，所以这一步后，a 的值变为 (a0 ^ b0) ^ a0。根据异或操作的性质 (x ^ y) ^ x = y，我们可以简化为：a = (a0 ^ b0) ^ a0 = b0

此时：

• a = b0，b = a0