【LeetCode刷题】Day06 哈希表基础Ⅱ

Elinor_

已于 2023-01-31 15:48:54 修改

阅读量214

点赞数

分类专栏： LeetCode题目总结文章标签： leetcode 散列表算法

于 2023-01-31 15:45:55 首次发布

本文链接：https://blog.csdn.net/Elinor_/article/details/128811714

版权

LeetCode题目总结专栏收录该内容

9 篇文章 1 订阅

订阅专栏

LeetCode454-四数相加Ⅱ

题目描述：给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1.(0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2.(1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
题目链接：https://leetcode.cn/problems/4sum-ii/

解题思路

将a+b放进map中并记录其出现的次数
遍历c+d，若0-(c+d)在map中，则满足条件的个数count加上map中此key对应的value

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :type nums3: List[int]
        :type nums4: List[int]
        :rtype: int
        """
        m1 = dict();
        count = 0;
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                k = nums1[i] + nums2[j];
                if k not in m1:
                    m1[k] = 1;
                else:
                    m1[k] += 1;
        for i in range(len(nums3)):
            for j in range(len(nums4)):
                k = nums3[i] + nums4[j];
                if 0 - k in m1:
                    count = count + m1[0 - k];
        return count;

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        # use a dict to store the elements in nums1 and nums2 and their sum
        hashmap = dict()
        for n1 in nums1:
            for n2 in nums2:
                if n1 + n2 in hashmap:
                    hashmap[n1+n2] += 1
                else:
                    hashmap[n1+n2] = 1
        
        # if the -(a+b) exists in nums3 and nums4, we shall add the count
        count = 0
        for n3 in nums3:
            for n4 in nums4:
                key = - n3 - n4
                if key in hashmap:
                    count += hashmap[key]
        return count

心得体会

这道题自己写思路也是对的，但是一直超时，看答案后发现，我用了map.keys()这个函数提取keys，删除后就不超时了，可能这个函数消耗了大量时间。注意以后判断一个元素在不在map的key中直接写map即可，不需要提取。

LeetCode383-救赎金

题目描述：给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
题目链接：https://leetcode.cn/problems/ransom-note/

解题思路

暴力穷举
map解决
数组解决

1 暴力穷举

两层循环
这种写法看一下即可，昨天第一题的暴力穷举自己没写，因为感觉内循环删除元素有点麻烦，可以参考下这个写法

// 时间复杂度: O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        for (int i = 0; i < magazine.length(); i++) {
            for (int j = 0; j < ransomNote.length(); j++) {
                // 在ransomNote中找到和magazine相同的字符
                if (magazine[i] == ransomNote[j]) {
                    ransomNote.erase(ransomNote.begin() + j); // ransomNote删除这个字符
                    break;
                }
            }
        }
        // 如果ransomNote为空，则说明magazine的字符可以组成ransomNote
        if (ransomNote.length() == 0) {
            return true;
        }
        return false;
    }
};

2 map解决

map分别统计两个字符串字符及其个数
字符串1的所有字符要含于字符串2，即在字符串1中出现的所有字符都要在字符串2中有，并且字符串1中字符对应的个数要小于等于此字符在字符串2中的个数
注意：没必要定义两个map，可以定义一个map，在遍历字符串2的时候减个数，然后判断value是否均小于等于0即可，即昨天第一题中的另一种写法

python写法1

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        m = {};
        n = {};
        for ch in ransomNote:
            if ch not in m:
                m[ch] = 1;
            else:
                m[ch] += 1;
        for ch in magazine:
            if ch not in n:
                n[ch] = 1;
            else:
                n[ch] += 1;
        for key,value in m.items():
            if key in n and value <= n[key]:
                continue;
            else:
                return False;
        return True;

python写法2

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        c1 = collections.Counter(ransomNote)
        c2 = collections.Counter(magazine)
        x = c1 - c2
        #x只保留值大于0的符号，当c1里面的符号个数小于c2时，不会被保留
        #所以x只保留下了，magazine不能表达的
        if(len(x)==0):
            return True
        else:
            return False

注意：哈希表在python中可以用collections.Counter计数来体现。该方法用于统计某序列中每个元素出现的次数，以键值对的方式存在字典中。但类型是Counter。

3 数组解决

字母输入a-z，定义大小为26的数组做哈希即可
若字符串1中映射到的哈希桶中数为0，则证明字符串2中没有此字符或者此字符没有1多，返回false

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:

        arr = [0] * 26

        for x in magazine:
            arr[ord(x) - ord('a')] += 1

        for x in ransomNote:
            if arr[ord(x) - ord('a')] == 0:
                return False
            else:
                arr[ord(x) - ord('a')] -= 1
        
        return True

4 心得体会

本题就是看前面字符串是否含于后面字符串，和昨天的第一题差不多，注意判断条件是含于，所以判断条件应用<=即可。

LeetCode15-三数之和

题目描述：给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
题目链接：https://leetcode.cn/problems/3sum/

解题思路

哈希解法
双指针法

1 哈希解法

两层for循环就可以确定 a 和 b 的数值了
可以使用哈希法来确定 0-(a+b) 是否在数组里出现过

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c);// 三元组元素c去重
                } else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

注意：
哈希法可以做，但是去除重复的三元组非常困难，细节会照顾不到。（上述代码我没看，感觉三数之和、四数之和比较难，今天脑子不想再思考了TwT，以后看吧)

2 双指针法

首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上
依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]
移动left 和right：如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些
如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止
时间复杂度：O(n^2)

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = [];
        nums.sort();
        for i in range(len(nums)):
            if nums[i] > 0: # 剪枝
                break;
            if i > 0 and nums[i] == nums[i-1]: # 去重
                continue;
            left = i+1;
            right = len(nums)-1;
            while(left < right):
                if nums[i]+nums[left]+nums[right] == 0:
                    res.append([nums[i], nums[left], nums[right]]);
                    while(left < right and nums[left] == nums[left+1]):
                        left += 1;
                    while(left < right and nums[right] == nums[right-1]):
                        right -= 1;
                    left += 1;
                    right -= 1;
                elif nums[i]+nums[left]+nums[right] > 0:
                    right -= 1;
                else:
                    left += 1;
        return res;

3 心得体会

三数之和去重比较难想，一开始想用哈希，但是不会去重；后来想到了排序做，但是没深想指针怎么去动，也没有想过去重的具体操作，这个题后续还要再好好理解一下。重点理解：a，b，c如何做去重。

LeetCode18-四数之和

题目描述：给你一个由 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
你可以按任意顺序返回答案。
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
题目链接：https://leetcode.cn/problems/4sum/

解题思路

双指针法

1 双指针法

在三数之和上加一层循环即可
外层循环：固定k，移动i，left，right找到结果
内层循环：固定k，固定i，移动left，right找到结果
k的去重，i的去重，剪枝等操作要分析
剪枝：注意target可能为负
i的去重，注意此时i是在k后面一位的元素，所以判断条件不是i>0，而是i-k-1>0

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        res = [];
        nums.sort();
        for k in range(len(nums)):
            if nums[k] > target and target > 0: # 剪枝
                break;
            if k > 0 and nums[k] == nums[k-1]: # 去重
                continue;
            for i in range(k+1, len(nums)):
                if nums[k]+nums[i] > target and target > 0: # 剪枝
                    break;
                if i-k-1 > 0 and nums[i] == nums[i-1]: # 去重
                    continue;
                left = i+1;
                right = len(nums)-1;
                while(left < right):
                    if nums[k]+nums[i]+nums[left]+nums[right] == target:
                        res.append([nums[k], nums[i], nums[left], nums[right]]);
                        while(left < right and nums[left] == nums[left+1]):
                            left += 1;
                        while(left < right and nums[right] == nums[right-1]):
                            right -= 1;
                        left += 1;
                        right -= 1;
                    elif nums[k]+nums[i]+nums[left]+nums[right] > target:
                        right -= 1;
                    else:
                        left += 1;
        return res;

2 心得体会

四数之和本以为看了三数之和就会了，但是脑子里的动态模拟并不好，没有写出来，四个指针感觉脑子里动的更乱了。看了视频讲解后勉强理解，后续还要看看。重点理解：剪枝和去重的具体操作。

总结

三数之和，四数之和的双指针法比较难，后续要再多看看，思想其实还可以，自己也想到了先排序在做，但是其中的细节自己考虑不好，去重，剪枝的具体操作比较难想出来，希望下次遇到这种题目可以自己写出来。三数之和算是能理解，四数之和加了一层循环后需要注意的细节更多，而且多了一层循环，脑子里的动态演示不是很清晰了，本来以为三数之和看了视频写出来，四数之和自己就能写，结果四数也是看了视频才勉强理解，但是目前还是没有三数之和理解的清楚。
三数之和的哈希解法如何去重没看，有时间要看一下，因为不会list[[list]]这样的去重，自己写的时候查到set的键值不能是列表，不能用set去重(可能只能讨论了？
前两道题还可以，第一题思路自己想出来了，但是自己写的代码一直超时，发现是我判断在不在map中写了keys，可能keys这个操作耗时间严重，以后多注意，可以直接写在不在某个map中，不用非得写在不在map的keys里面。