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

---

今日记录

---

454.四数相加Ⅱ

Leetcode链接

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

思路

这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况
题目里有：计算多少个元组–需要统计次数–使用map（value放出现次数）

1. 将 nums1,nums2分为一组，对nums1,nums2进行二重循环，将nums1[i]+nums[j]的结果作为key放入map,将求和的个数放入value中
2. nums3,nums4分为一组，同样用二重循环在map里寻找等于 -(nums3[k]+nums4[l])的key值，将对应的value累加起来

代码

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

383.赎金信

Leetcode链接

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

思路

难点：其实在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。
所以数组更加简单直接有效！

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

15.三数之和

Leetcode链接

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

思路

此题类似于前面的四数相加Ⅱ，但是是在不同组数组包含的三个元素不能完全一样(EX:[-1,-1,0,0,1,1] 能取两组 [-1,0,1] 但是结果只要一组)
使用双指针法

难点记录：
需要对数组进行排序！
去重操作：需要对i,left,right都操作一次

1. 对 i : 在每一次for循环的时候，先判断nums[i] == nums [i-1] 如果一样则continue进入下一次for循环；
2. 对 left 和 right : 在每一次将符合条件的数组存好后，判断后续的left 和 right是否重复，重复则持续right–和left++

● 三数之和去重为什么碰到相邻相同的要元素跳过：
一个是因为之前已经判断过，不必再判断，还有一个是因为必须要减枝，不然会超时，还有就是题目要求不能重复，再次执行会导致重复添加数据。
● 三数之和这么去重，是怎么保证a的去重，而没有把合适的b也去掉了呢？
因为b在a后面，当a的数字确定，后面b+c的值也确定，比如序列-2,-2,4,8,16,第一次遇到某一个a=-2的时候已经把后面所有b+c=2的情况跑完了，第二次再次遇到a=-2的时候已经没有跑的意义了

代码实现

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(); i++) {
            if (nums[i] > 0) return result; // 如果最小的都大于零，不可能取到
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            int left = i + 1, right = nums.size() - 1;
            while (left < right) {
                if ((long) nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                } else if ((long) 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++;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

18.四数之和

Leetcode链接

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

难点：
去重：需要对i,k都进行去重

代码实现

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 k = i + 1; k < nums.size(); k++) {
                if (nums[i] + nums[k] > target && nums[i] + nums[k] >= 0)
                    break;
                if (k > i + 1 && nums[k] == nums[k - 1])
                    continue;

                int left = k + 1, right = nums.size() - 1;
                while (left < right) {
                    if (nums[i] + nums[k] + nums[left] + nums[right] > target)
                        right--;
                    else if (nums[i] + nums[k] + nums[left] + nums[right] <
                             target)
                        left++;
                    else {
                        result.push_back(vector<int>{nums[i], nums[k], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1])
                            left++;
                        while (left < right && nums[right] == nums[right - 1])
                            right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};

因为数字之和比较大，所以应该使用long

---

总结