学习记录@代码随想录day7:哈希表part02

zmmyzdq

已于 2023-07-18 19:02:53 修改

阅读量102

点赞数

文章标签： python

于 2023-07-18 17:31:26 首次发布

本文链接：https://blog.csdn.net/qq_40357993/article/details/131784600

版权

学习记录@代码随想录day7:哈希表part02

454 .四数相加II

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

'''数组暴力'''
class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        count=0
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                for k in range(len(nums3)):
                    for l in range(len(nums4)):
                        if nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0:
                            count+=1
        return count
#长输入超时

看完视频自己写的代码

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        m_list=[]
        count=0
        #遍历两个数组，将a+b的值放到map中
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                m_list.append(nums1[i]+nums2[i])
        #遍历后两个数组，查看0-（c+d）的值是否在map中
        for k in range(len(nums3)):
            for l in range(len(nums4)):
                targe=0-(nums3[k]+nums4[l])
                if targe in m_list:
                    count+=1
        return count

以上代码执行报错，查了下原因是如果数组中有重复元素则会导致结果出错。

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        m_list={}
        count=0
        #  #遍历两个数组，将a+b的值放到字典中
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                s=nums1[i]+nums2[j]
                #m_list.get(s, 0) 表示获取字典中键为 s 的值，如果键不存在，则返回默认值 0。
                #然后，将获取到的值加 1，表示该元素出现了一次，最后将结果保存回字典中。
                #{-1: 1}
				#{-1: 1, 0: 1}
				#{-1: 1, 0: 2}
				#{-1: 1, 0: 2, 1: 1}
                m_list[s]=m_list.get(s,0)+1
        #遍历后两个数组，查看0-（c+d）的值是否在字典中
        for k in range(len(nums3)):
            for l in range(len(nums4)):
                targe=0-(nums3[k]+nums4[l])
                if targe in m_list:
                    count+=m_list[targe]
        return count

383. 赎金信

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

在这里插入图片描述
学习前写的代码：

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        m_dict={}
        #将magazin中的字符加入字典并计数
        for i in range(len(magazine)):
            m_dict[magazine[i]]=m_dict.get(magazine[i],0)+1
         #判断ransomNote的字符是否能在字典中，如果在，移除当前字符
        for j in range(len(ransomNote)):
            if ransomNote[j] in m_dict:
                m_dict.pop(ransomNote[j])
            else:
                return False
        return True

以上代码存在的问题是，ransomNote的所有元素都会被遍历，如果某一个元素在magazine中不存在，就是返回false，显现不符合题目要求。看了讲解，想复杂了。o(╥﹏╥)o
只要保证randomNote中每个字符数数量大于等于nagazine就可以了!!!
自己写了下很暴力的正确解法，虽然结果对了，但是确实很麻烦拉

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        m_dict={}
        r_dict={}
        for i in range(len(magazine)):
            m_dict[magazine[i]]= m_dict.get(magazine[i], 0) + 1
        print(m_dict)
        for j in range(len(ransomNote)):
            r_dict[ransomNote[j]] =r_dict.get(ransomNote[j], 0) + 1
        print(r_dict)
        for i in m_dict:
            if i not in r_dict:
                r_dict[i]=r_dict.get(i,0)
        for i in r_dict:
            if i not in m_dict:
                m_dict[i]=m_dict.get(i,0)
        m=0
        for i in r_dict:
            #print(r_dict[i],m_dict[i])
            if r_dict[i]>m_dict[i]:
                return False
            m+=1
            if m==len(r_dict):
                return True

代码随想录代码：

'''数组'''
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        ransom_count = [0] * 26
        magazine_count = [0] * 26
        for c in ransomNote:
            ransom_count[ord(c) - ord('a')] += 1
        for c in magazine:
            magazine_count[ord(c) - ord('a')] += 1
        return all(ransom_count[i] <= magazine_count[i] for i in range(26))
#自己抄的一个版本，其实是一样的，就是不明白最后还可这样返回值
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        ransom_count=[0]*26
        maga_count=[0]*26
        for c in ransomNote:
            ransom_count[ord(c) - ord('a')]+=1
        for c in magazine:
            maga_count[ord(c) - ord('a')]+=1
        i=0
        while i<26:
            if ransom_count[i]>maga_count[i]:
                return False
            i+=1
        return True
'''defaultdict'''
#defaultdict 是 Python 中的一个字典类型，它和普通的字典相比有一个重要的区别：在访问不存在的键时，
#defaultdict 会使用一个默认值来初始化这个键的值。这个默认值可以是任何一个可调用对象，例如一个函数、
#一个 lambda 表达式、一个类等。
from collections import defaultdict
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
    	#初始化一个defaultdict
        hashmap = defaultdict(int)
        for x in magazine:
            hashmap[x] += 1
        # # 遍历 ransomNote 中的每个字符
        for x in ransomNote:
        	#使用 `hashmap.get(x)` 方法获取字典中某个键的值时，如果该键不存在，会返回 `None`。     
            value = hashmap.get(x)
            if not value:
                return False
            else:
                hashmap[x] -= 1

        return True
'''字典'''
#这个方法就是我第一个方法的思路o(╥﹏╥)o
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        counts={}
        for c in magazine:
            counts[c]=counts.get(c,0)+1
        for c in ransomNote:
        	#如果在ransomNote中的字符没有在counts中或者，字符已经被“使用”
            if c not in counts or counts[c] ==0:
                return False
            counts[c]-=1
        return True

15. 三数之和

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

尝试做了下，解决不了顺序的情况。
用双指针法，来解决：
1.先对数组排序
2.循环数组
3.i,left=i+1,right=len(nums)-1
4.对i，left,right去重，跟前一个比较

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result=[]
        nums.sort()
        for i in range(len(nums)):
            #如果第一个元素已经大于零，不需要进行下一步
            if nums[i]>0:
                return result
            #跳过相同的元素以避免重复
            if i>0 and nums[i]==nums[i-1]:
            	#continue 语句的作用是跳过本次循环中剩余的代码，直接进入下一次循环。
                continue
            
            left=i+1
            right=len(nums)-1
            while right > left:
                sum_=nums[i]+nums[left]+nums[right]
                if sum_>0:
                    right-=1
                elif sum_<0:
                    left+=1
                else:
                    result.append([nums[i],nums[left],nums[right]])
                    #跳过相同的元素以避免重复
                    while right>left and nums[right]==nums[right-1]:
                        right-=1
                    while right>left and nums[left]==nums[left+1]:
                        left+=1
                    right-=1
                    left+=1
        return result

18. 四数之和

'''
给你一个由 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
你可以按 任意顺序 返回答案 。
'''

思路：把四数之和转换为三数之和，再加一层for循环实现

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        result = []
        for i in range(n):
            #如果数组全为正且比target大,可接束
            if nums[i] > target and nums[i] > 0 and target > 0:# 剪枝（可省）
                break
            if i > 0 and nums[i] == nums[i-1]:# 去重
                continue
            #相对于三数之和，多了一层for循环，用于把前两个数和为一个整体，再套用双指针思想
            for j in range(i+1, n):
                #同上
                if nums[i] + nums[j] > target and target > 0: #剪枝（可省）
                    break
                if j > i+1 and nums[j] == nums[j-1]: # 去重
                    continue
                
                left, right = j+1, n-1
                while left < right:
                    s = nums[i] + nums[j] + nums[left] + nums[right]
                    if s == target:
                        result.append([nums[i], nums[j], 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 s < target:
                        left += 1
                    else:
                        right -= 1
        return result