代码随想录算法训练营0514| 454.四数相加II 、383. 赎金信、15. 三数之和 、18.四数之和

刷题刷到现在感觉不是不会，是这个思路很难想到，所以这个思路的积累，也是靠多刷题实现的吗？第一个想出来这种方式的人完全是天才！

454.四数相加II 

思路是将四个列表简化为两个列表（四数相加简化为两数相加）：两两一组，首先用遍历的方式求出两个列表的元素所有可能的和，这样就将四个变量简化为了两个变量，接下俩走两数之和的路即可

享受和卡哥写的不一样的感觉，啊哈哈哈，哪怕只是一点点微不足道的区别

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        sum_num1 = {}
        for i in nums1:
            for j in nums2:
                sum_num1[i+j] = sum_num1.get(i+j,0)+1#key为和，value为出现次数(因为要统计满足条件的元素数，因此需要统计出现次数)
        num_tuple = 0
        for i in nums3:
            for j in nums4:
                cur_sum_another = 0-i-j
                if cur_sum_another in sum_num1:
                    num_tuple +=  sum_num1[cur_sum_another]
        
        return num_tuple

卡哥还用了一个defaultdict（第一次见）语法：

from collections import defaultdict 

    dicA = defaultdict(lambda: 默认初始值)
    eg：dicA = defaultdict(lambda: 0)

注意①要import，②意为创建一个空字典，如果访问的key 是dicA中没有的，那么把这个key加进词典，自动把该key对应value赋初值0，congress方便直接加入运算。

注意语法lambda和默认值之间是冒号 ':'

from collections import defaultdict 
class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        record = defaultdict(lambda:0)
        for i in nums1:
            for j in nums2:
                record[i+j] += 1
        
        num_tuple = 0
        for i in nums3:
            for j in nums4:
                cur_sum_anouther = 0-i-j
                num_tuple += record[0-i-j]#0-i-j不存在时,则num_tuple+0

        return num_tuple

也写了一遍熟悉语法

383. 赎金信 

就是一个 242.有效的字母异位词 的花式应用。

原来的思路是：算出链各个字符串的hashtable，然后做减法，得到的数组中如果没有小于0的元素，则返回true。但是Python中，得到的hashtable是个列表可恶，列表是不可以直接做减法的。

于是想到得到先得到magazine对应的hashtable，然后遍历ransomNote，出现一个则对应位置的val-1，如下：

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        hashtable = [0]*26
        for i in magazine:
            index = ord(i)-ord('a')
            hashtable[index] += 1

        for i in ransomNote:
            index = ord(i)-ord('a')
            hashtable[index] -= 1

        for i in hashtable:
            if i<0:
                return i==0#false
        return 1==1#true

15. 三数之和 

这个题我拿到手的思路是完全暴力解，套三层for循环，理论上是没啥问题的

这个题用双指针做，但是有个绝妙的思想是，先对nums做排序（题目有说直接输出元素+不考虑输出的三元组的顺序），方便知道指针应该往哪儿移动。

i从左向右，left从左向右，right从右向左。sum = i+left+right的num之和，如果sum<0,left右移，>0直接right左移。注意元素的去重

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result = []
        nums.sort()#先对nums排序
        if nums[0]>0:#最小的元素>0,break,可能有[0,0,0]的数组因此不能取>=0
            return result

        size = len(nums)-1
        for i in range(size-1):
            if i>0 and nums[i]==nums[i-1]:#i位置元素的去重
                continue #直接进入下一轮循环

            left = i+1
            right = size
            while left<right:
                cur_sum = nums[i]+nums[left]+nums[right]
                if cur_sum >0:#和大了，right左移
                    right -= 1
                elif cur_sum <0:
                    left += 1                    
                else:
                    result.append([nums[i],nums[left],nums[right]])#由于返回的是元素的值，而非索引，因此这样是会出现重复值的，所以需要去重

                    ## 元素的去重,注意这个缩进位置
                    while left<right and nums[right-1]==nums[right]:
                        right -= 1
                    while left<right and nums[left+1] == nums[left]:
                        left += 1

                    left += 1
                    right -= 1#因为要去除掉重复元素，所以left和right都移动
        
        return result

18. 四数之和 

比三数多一层循环，但是要小心nums[0]>target但是nums中存在负数相加的情形，因此不可以直接做nums[0]>target，就直接break的判断

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        record = []

        # if nums[0]>target:#存在负数相加的情况，因此这一步不能加
        #     return record

        size = len(nums)-1
        for i in range(size-2):
            if i >0 and nums[i]==nums[i-1]:#第一层的去重
                continue
            
            j=i+1#第二个指针
            while j < size-1:
                left = j+1
                right = size
                while left < right:
                    cur_sum = nums[i]+nums[j]+nums[left]+nums[right]
                    if cur_sum > target:#和偏大，right左移
                        right -= 1
                    elif cur_sum < target:#和偏小，left右移
                        left += 1
                    else :
                        record.append([nums[i],nums[j],nums[left],nums[right]])

                        while left<right and nums[right-1]==nums[right]:#最底层俩指针的去重
                            right -= 1
                        while left<right and nums[left+1]==nums[left]:
                            left += 1

                        left += 1 #不要忘记非去重情形下的left和right的移动方式
                        right -= 1
                
                while j<size-2 and nums[j+1]==nums[j]:#第二层指针的去重
                    j += 1

                j += 1

        return record