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

最新推荐文章于 2024-06-07 21:12:47 发布

Echo0058

最新推荐文章于 2024-06-07 21:12:47 发布

阅读量262

点赞数

文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/qq_45139353/article/details/127380690

版权

今天继续哈希
day7
● 454.四数相加II
● 383. 赎金信
● 15. 三数之和
● 18. 四数之和

四数相加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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/4sum-ii

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        from collections import defaultdict
        dic = defaultdict(int)

        for num1 in nums1:
            for num2 in nums2:
                sum = num1 + num2
                dic[sum] += 1
        print(dic)
        count = 0
        for num3 in nums3:
            for num4 in nums4:
                sum = num3 + num4
                if -sum in dic:
                    count += dic[-sum]

        return count

简写：

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        from collections import defaultdict
        dic = defaultdict(int)
        # dic = defaultdict(lambda: 0)
        for num1 in nums1:
            for num2 in nums2:
                dic[num1 + num2] += 1
        count = 0
        for num3 in nums3:
            for num4 in nums4:
                if -(num3 + num4) in dic:
                    count += dic.get(-(num3 + num4), 0) # 在就返回value，不在就返回0

        return count

383. 赎金信

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/ransom-note

暴力解法：

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        ransomNote = list(ransomNote)
        for s in magazine:
            for k in ransomNote:
                if s == k:
                    ransomNote.remove(k)
            
        if len(ransomNote) == 0:
            return True
        return False

法二：哈希数组

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        record = [0]*26
        if len(ransomNote) > len(magazine):
            return False
        
        for s in magazine:
            record[ord(s)-ord('a')] += 1
        
        for k in ransomNote:
            if record[ord(k)-ord('a')] == 0:
                return False
            else:
                record[ord(k)-ord('a')] -= 1

        return True

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

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

15.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/3sum

双指针法

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        result = []
        for i in range(n):
            if nums[i] > 0:  # 排序之后如果a>0，后面的数都比前面的大，三数之和不可能为0
                return result
            if i > 0 and nums[i] == nums[i-1]: # a 去重
                continue
            left = i + 1
            right = n - 1
            while right > left:
                if nums[i] + nums[left] + nums[right] > 0:
                    right -= 1
                elif nums[i] + nums[left] + nums[right] < 0:
                    left += 1
                else:
                    result.append([nums[i], nums[left], nums[right]])
                    while right > left and nums[right] == nums[right-1]:
                        right -= 1
                    while left < right and nums[left] == nums[left+1]:
                        left += 1
                    right -= 1
                    left += 1
        
        return result

法二：

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        if len(nums) < 3: return []
        nums, res = sorted(nums), []
        for i in range(len(nums) - 2):
            cur, l, r = nums[i], i + 1, len(nums) - 1
            if res != [] and res[-1][0] == cur: continue # Drop duplicates for the first time.

            while l < r:
                if cur + nums[l] + nums[r] == 0:
                    res.append([cur, nums[l], nums[r]])
                    # Drop duplicates for the second time in interation of l & r. Only used when target situation occurs, because that is the reason for dropping duplicates.
                    while l < r - 1 and nums[l] == nums[l + 1]:
                        l += 1
                    while r > l + 1 and nums[r] == nums[r - 1]:
                        r -= 1
                if cur + nums[l] + nums[r] > 0:
                    r -= 1
                else:
                    l += 1
        return res

四数之和

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/4sum

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        result = []
        n = len(nums)
        for i in range(n):
            if nums[i] > target and nums[i] >=0:
                break
            if i > 0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1, n):
                if nums[i]+nums[j] > target and nums[i]+nums[j] >=0:
                    break
                if j > i+1 and nums[j] == nums[j-1]:
                    continue
                left, right = j+1, n-1
                while left < right:
                    a = nums[i] + nums[j] + nums[left] + nums[right]
                    if a < target:
                        left += 1
                    elif a > target:
                        right -= 1
                    else:
                        result.append([nums[i], nums[j], nums[left], nums[right]])
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        left += 1
                        right -=1
                        
        return result