# 代码随想录——算法刷题--哈希表总结（454. 四数相加 II 383. 赎金信 15. 三数之和 （4）18. 四数之和）

代码随想录——算法刷题–哈希表总结（454. 四数相加 II 383. 赎金信 15. 三数之和 （4）18. 四数之和）

（1）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

思路：

（1）遍历前两个数组之和，用哈希表记录每一个和数值(nums1[i] + nums2[j])出现的次数
（2）然后遍历后两个数组之和，用record记录每次（0-（nums1[i] + nums2[j]））出现的次数

Python代码如下：

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        record = dict()
        times = 0
        for i in nums1:
            for j in nums2:                      #遍历两个数组
                if i+j in record:                #记录和出现的次数
                    record[i+j] += 1
                else:
                    record[i+j] = 1
        for i in nums3:
            for j in nums4:
                key = 0 - i - j
                if key in record:
                    times += record[key]        #每次的值代表有多少个
        return times

（2）383. 赎金信

题目描述：
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

思路：

（1）题目介绍只有小写字母，又想到26个字母之间SCIII值相邻，所以用数组作为哈希表结构储存
（2）先遍历ransomNote，每出现一个字符对应加一
（3）再遍历magazine，在出现一个再数组上的字符减一，没有出现在数组的直接跳过本次循环
（4）遍历数组，如果有不为0的直接返回False,否则返回True

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        record = [0]*26
        for i in ransomNote:                      #order()返回SCII值
            record[ord(i)-ord('a')] += 1          #记录出现次数
        for i in magazine:
            if record[ord(i)-ord('a')] ==0:      #没有出现在哈希表直接跳过
                continue
            record[ord(i)-ord('a')] -= 1         #出现的减一
        for i in record:
            if i != 0:
                return False
        return True

（3）15. 三数之和

题目描述：
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

思路：

1. 哈希表法，两层for循环就可以确定 a 和b 的数值，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，然后再进行去重，但是去重相当麻烦，一不小心就超时，而且python用哈希基本上都会超时。
2. 双指针法：
   （1）先对数组进行排序
   （2）确定i=0，left = i+1,right = len(nums)-1,进入一层循环确定总和
   （3）总和>0,right-=1, <0,left+=1, =0,放入结果向量

注意：
注意去重

Python代码：

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result = []
        i = 0
        nums.sort()
        for i in range(len(nums)):
            if nums[i]>0:
                break
            if i>0 and nums[i] == nums[i-1]:         #对i去重
               
                continue
            left = i + 1
            right = len(nums) - 1
            while left < right:
                total = nums[i] + nums[left] +nums[right]
                if total > 0:
                    right -= 1
                elif total < 0:
                    left += 1
                else :
                    result.append([nums[i],nums[left],nums[right]])
                    while left != right and nums[right] == nums[right-1]: right -= 1                             #对left去重
                       
                    while left != right and nums[left] == nums[left+1]:left += 1                                #对right去重
                        
                    left += 1
                    right -= 1
           
        return result

（4）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
你可以按 任意顺序 返回答案 。

思路：

（1）跟上题三数之和一样，只是在外面再多加一次循环
（2）然后去重逻辑和剪枝操作跟上题一样

注意问题：

python中的循环的使用
用while就会超时，而用for循环就可顺利通过，不理解但大为震惊，
while代码如下：

 			j = i+1
            while j < n:
            	.....
            	j+=1

for代码如下：

for j in range(i+1,n):

总代码如下：

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        n = len(nums)
        nums.sort()
        result = []
        for i in range(n): 
            if nums[i]>target and nums[i]>0:     #i剪枝
                break
            if i>0 and nums[i] == nums[i-1]:     #i去重
                continue
            for j in range(i+1,n):
                if nums[i]+nums[j]>target and nums[j]>0:
                    break
                if j >i+1 and nums[j] ==nums[j-1]:
                    continue
                left = j+1
                right = n-1
                while left<right:
                    total = nums[i]+nums[j]+nums[left]+nums[right]
                    if total>target:
                        right -= 1
                    elif total<target:
                        left += 1
                    else:
                        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
                
        return result

哈希表总结

数组：
可以作为简单的哈希表，但是其大小是受限的

如果数组太大：
（1）数组的大小是有限的，受到系统栈空间（不是数据结构的栈）的限制。
（2）如果数组空间够大，但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

集合（set）：
集合不受大小的限制
而且利用率较高

映射（dict）
使用数组和set来做哈希法的局限。

（1）数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
（2）set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

哈希表一般都是用来快速判断一个元素是否出现集合里，或者记录出现的次数