算法训练第七天 | 哈希表 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

最新推荐文章于 2024-08-09 20:36:57 发布

Nuyoahuoy-

最新推荐文章于 2024-08-09 20:36:57 发布

阅读量107

点赞数

文章标签：算法散列表 leetcode

本文链接：https://blog.csdn.net/weixin_44551379/article/details/128543168

版权

文章介绍了使用哈希表解决LeetCode上的几道算法题，包括四数之和II、赎金信、三数之和及四数之和问题。通过哈希表存储元素出现的次数，优化查找效率，同时讨论了双指针技巧在解决数组问题中的应用。

摘要由CSDN通过智能技术生成

LeetCode 454.四数相加II

题目链接

454.四数相加II

思路

这题思路跟两数相加的思路类似，也是通过在map里面放key，找target-遍历值在不在map里面。区别在于，这次不仅判断有没有，还要统计有多少个。
所以这题的map存储的value是key的个数，把四组分成a+b,c+d两组值，a+b放进map，c+d就是遍历值，再进行找的操作
（代码如下：）

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        from collections import defaultdict
        map_ = defaultdict(int)
        result = 0
        for i in nums1:
            for j in nums2:
                map_[i + j] += 1
        for i in nums3:
            for j in nums4:
                if (0 - i - j) in map_.keys():
                    #map_[0 - i - j] -= 1  #不需要--，直接结果是+总次数就好了
                    result += map_[-i-j]    #注意不是++，是加上key出现的次数
        return result

反思

遇到的问题：a+b的结果可能不止出现一次，所以对于找0-（c+d）来说最后的结果不是++而是+value（也就是总次数）
以及每个位置是可以重复被利用的，这跟四数之和不同，它是一个位置的数只能用一次

LeetCode 383. 赎金信

题目链接

383. 赎金信

思路

大致想法是把magazine里面的字母存成map，value是字母出现次数，再遍历ransomNote的字母有的话就–，最终次数全部》=0就返回true，否则返回false
（思路类似但是卡哥解法是用数组，确实因为规定了小写字母所以只有26位。用数组是更好的）

def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        record = [0] * 26
        for i in range(len(magazine)):
            record[ord(magazine[i]) - ord('a')] += 1
        for j in range(len(ransomNote)):
            if record[ord(ransomNote[j]) - ord('a')] == 0:
                return False
            else:
                record[ord(ransomNote[j]) - ord('a')] -= 1
        '''for z in record:
            if z < 0:
                return False'''  #自己写的有欠缺，其实不用再做这个for了，直接在上一个for判断
        return True

反思

能用数组还是数组把，毕竟效率最优

LeetCode 15. 三数之和

题目链接

15. 三数之和

思路

哈希的思路就是a+b的值丢进map,然后遍历c需要的值，跟前面思路一样
下面是用双指针的思想，注意的细节就是怎么去重以及在什么位置上去重

def threeSum(self, nums: List[int]) -> List[List[int]]:
        result = []
        n = len(nums)
        nums = sorted(nums)    #因为没规定打印索引，所以可以先排序，更方便
        for i in range(n):
            if i == 0 and nums[i] > 0: 
                break

            left = i + 1
            right = n - 1
            #先对i去重
            if i >= 1 and nums[i] == nums[i-1]:
                continue
            while left < right:
                if nums[i] + nums[left] + nums[right] == 0:
                    result.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 result

反思

这题好难。。。
主要是很多细节处理，包括一开始一直不理解为什么要去重（后面知道是因为重复计算已经算过的内容，因为数一样）
细节：
1、双指针思想，跳出循环的条件
2、i left right分别去重
以及我不知道怎么把拿到的数建成数组放进二维数组里面（解决方案如下：）

ans = []
ans.append([nums[i], nums[left], nums[right]])

心态崩了，好麻，后面重刷吧

LeetCode 18. 四数之和

题目链接

18. 四数之和

思路

与三数之和相似，在三数的基础上再套一个for循环，注意去重和剪枝的细节部分（写入的条件范围）
（代码如下：）

def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        result = []
        nums.sort()
        for k in range(len(nums)):
            #剪枝1
            if nums[k]>target and target>0 and nums[k]>0:
                break  
            #去重
            if k > 0 and nums[k] == nums[k-1]: continue
            for i in range(k+1,len(nums)):
                #剪枝2
                if nums[k]+nums[i]>target and target>0 and nums[k]+nums[i]>0:
                    break   
                if i > k+1 and nums[i] == nums[i - 1]: continue    #细节：i > k+1

                left = i + 1
                right = len(nums) - 1

                while left < right:
                    total = nums[k] + nums[i] + nums[left] + nums[right]
                    if total < target:
                        left += 1
                    elif total > target:
                        right -= 1
                    else:
                        result.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
        return result