代码随想录算法训练营第七天 | 哈希法2

Yirschen

已于 2024-02-21 21:17:37 修改

阅读量94

点赞数

文章标签： leetcode

于 2023-04-10 23:34:23 首次发布

本文链接：https://blog.csdn.net/Yirschen/article/details/130072644

版权

454 map作为哈希表

讲解视频：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

状态：思路想出来了，没忍住看了文章讲解的文字部分。代码可以写出来，值得作为例题。

思路

用两层for循环，将nums1和nums2的各个元素分别相加，元素和作为unordered_map的key，元素和出现的次数作为value；
用两层for循环，将nums3和nums4的各个元素分别相加，计算相反数，若该相反数在map中存在，那么对应的value就是出现的次数。用cnt将每次迭代的value相加即可得到最终结果。

文章讲解的思路与上述思路一致：

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

代码

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

383 数组作为哈希表

讲解视频：无

文章讲解：代码随想录 (programmercarl.com)

状态：能直接做出。

思路

因为题目中只有小写字母，故用数组作为哈希表。

创建长度为26的数组record，用于存放magazine中每个字母出现的次数，record[0]代表字母a出现次数，record[1]代表字母b出现次数；
遍历magazine，统计magazine中每个字母出现的次数；
遍历ransomNote的各个字母，若出现一次，则从record中减去一次；一旦record中某个值小于0，则返回false。如果遍历完还没false，则返回true。

代码

bool canConstruct(string ransomNote, string magazine) {
	if (ransomNote.size() > magazine.size()) return false;    //若ransomNote的长度比magazine长，那么magazine肯定不够给ransomNote用
	int record[26] = { 0 };		// 用于存放magazine中每个字母出现的次数，record[0]代表字母a，record[1]代表字母b
	for (int i = 0; i < magazine.size(); ++i) {	//统计magazine中每个字母出现的次数
		record[magazine[i] - 'a']++;
	}
	// 遍历ransomNote的各个字母，若出现一次，则从record中减去一次;一旦record中某个值小于0，则返回false。如果遍历完还没false，则返回true
	for (int i = 0; i < ransomNote.size(); ++i) {
		record[ransomNote[i] - 'a']--;
		if (record[ransomNote[i] - 'a'] < 0)	return false;
	}
	return true;
}

15 双指针细节太多

讲解视频：梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

状态：哈希法的大思路想出来了，但是去重想不出来，去重太复杂了。推荐用双指针法，写不出来，细节太难。

思路

这道题的难点在结果的三元组要去重。这道题不推荐用哈希法，因为去重不好做，多多少少会有bug。Karl建议用双指针法。

双指针大体思路：

首先对数组排序，用for循环去遍历i的位置，得到a，剩下如何得到b和c？

当i固定时，b就是left最终所指向的值，c就是right最终所指向的值，初始化时left在i右边一个位置，right在数组最右边，

若nums[i]+nums[left]+nums[right]>0，说明这三个相加大了，因为i已经固定(即a的值无法改变)，只能通过左移right来减小三个数的和，即right–；
若nums[i]+nums[left]+nums[right]<0，说明这三个相加小了，只能通过右移left来增大三个数之和，即left++；
一旦nums[i]+nums[left]+nums[right]==0，这就是我们需要的结果：nums[i]、nums[left]、nums[right]，将三元组存到result二维数组中。

细节：对三元组去重！！【！！注意：要知道去重为什么不是nums[i]和nums[i+1]比，这个涉及到两种不同的去重。】
(1) 对nums[i]去重：①num[i]>0时，由于已经排过序，所以nums[left]、nums[right]必大于等于nums[i]，三数之和必大于0，故剪枝；②for循环时，若nums[i]==nums[i-1]，就continue，因为nums[left]和nums[right]是在for循环下的while循环内进行的。
(2）nums[left]和nums[right]的去重应该在找到一个三元组（收获结果）后进行，即遇到合适的结果只收割一个即可。若nums[left]==nums[left+1]，就left++直到nums[left]!=nums[left-1]；nums[right]同理，若nums[right]==nums[right-1]，就right–直到nums[right]!=nums[right+1]。

代码：代码中的3个细节如何解释，直接看视频就好了，太细了不好写。

vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());     //首先对数组排序
    for(int i = 0; i < nums.size(); i++){   //用for循环去遍历i的位置，得到a
        if(nums[i] > 0){    //细节1：排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            return result;
        }
        if (i > 0 && nums[i] == nums[i - 1]) {  //对a去重，细节2：为什么不是nums[i] == nums[i+1]
            continue;
        }

        int left = i + 1;   // 初始化left在i右边一个位置
        int right = nums.size() - 1;    // 初始化right在数组最右边
        while(left < right){
            if (nums[i] + nums[left] + nums[right] > 0) right--;    //三个数相加大了，右移right
            else if (nums[i] + nums[left] + nums[right] < 0) left++;    //三个数相加小了，左移left
            else {
                result.push_back(vector<int>{nums[i], nums[left], nums[right]});    // 找到想要结果
                // 细节3：去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;

                // 找到答案时，双指针同时收缩
                right--;
                left++;
            }
        }
    }
    return result;
}

18 双指针（15的进阶版）

讲解视频：难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

状态：做不出来。

思路

这道题是题目15的进阶版，思路相同，都是使用双指针法，解法就是在题目15的基础上再套一层for循环。

【题目15：三数之和】的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

【题目18：四数之和】的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况。不过去重细节有一些变化。

【题目15：三数之和】的双指针法就是将原本暴力O(n3)的解法，降为O(n2) 的解法；【题目18：四数之和】的双指针解法就是将原本暴力O(n4)的解法，降为O(n3) 的解法。

那么一样的道理，五数之和、六数之和等等都采用这种解法。

双指针的相关题目

双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：27、15、18；

链表相关双指针题目：206、19、02.07、142

代码

如下图，

nums[k]和nums[i]是确定的，然后靠left和right不断的向中间移动，去寻找合适的四元组，使之相加等于target。

代码的话，是在【题目15：三数之和】的基础上套了一层for循环来遍历k，区别主要在于剪枝和去重的部分。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            // ！剪枝处理
            if (nums[k] > target && nums[k] >= 0) { //细节1：因为后面的数相加必大于nums[k]，也就大于target
            	break; // 这里使用break，统一通过最后的return返回
            }
            // ！对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // ！2级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {//细节2：以nums[k] + nums[i]为整体
                    break;
                }
                // ！对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {	//细节3
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left) {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    } else if ((long) nums[k] + nums[i] + nums[left] + nums[right]  < target) {
                        left++;
                    } else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        // 对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;
    }
};