算法学习|Day7-哈希表|Leetcode454四数相加II，Leetcode383赎金信，Leetcode15三数之和，Leetcode18四数之和

最新推荐文章于 2024-09-12 19:02:20 发布

ambitious_Rgr

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量83

点赞数 1

文章标签：哈希表算法 python 数据结构 leetcode

本文链接：https://blog.csdn.net/WR_mmc/article/details/130113844

版权

本文介绍了使用哈希表和双指针法解决LeetCode上的四数相加II、赎金信、三数之和及四数之和问题，包括解题思路、代码实现和总结，强调了去重和剪枝的重要性。

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

一、Leetcode454(四数相加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

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

题目链接：力扣题目链接

解题思路

不需要去重
两个for循环，时间复杂度最低
保存和，和的次数map

方法:哈希表_map

第一个for循环计算前两个数组的和的所有情况和次数
第二个for循环计算后两个数组和的所有情况，它们和的负值出现在record则累加次数

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :type nums3: List[int]
        :type nums4: List[int]
        :rtype: int
        """
        record = {}
        count = 0
        # 计算前两个数组和的所有情况和对应次数
        for n1 in nums1:
            for n2 in nums2:
                sum1 = n1 + n2
                if sum1 in record:
                    record[sum1] += 1
                else:
                    record[sum1] = 1

        # 计算后两个数组和的所有情况,它们和的负值出现在record则累加次数
        for n3 in nums3:
            for n4 in nums4:
                sum2 = n3 + n4
                if -sum2 in record:
                    count += record[-sum2]

        return count

总结

相加=0，考虑正数+负数=0
两两组合for循环，时间复杂度低
存两个值就用字典保存(和/和的次数，同时不用去重)

二、Leetcode383(赎金信)

题目描述

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

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

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

输入：ransomNote = "a", magazine = "b"
输出：false

输入：ransomNote = "aa", magazine = "ab"
输出：false

输入：ransomNote = "aa", magazine = "aab"
输出：true

题目链接：力扣题目链接

解题思路

判断一个元素在另一个字符串中是否出现，26小写字母，明显考虑哈希表数组
判断出现的字符是否一样，次数是否一样

方法:哈希表_数组

第一个字符串放入数组做累加，查找过程做累减
出现负值马上返回false(说明要么没出现，要么次数不一样)

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        record = [0] * 26  # 只有26个小写字母
        # 将magazine中的元素放入record
        for m in magazine:
            record[ord(m) - ord("a")] += 1

        # 判断ransomNote
        for r in ransomNote:
            record[ord(r) - ord("a")] -= 1
            if record[ord(r) - ord("a")] < 0:
                return False
        return True

总结

注意哈希过程，index是数字映射还是字母映射！
注意写法ord(“a”)，引号
26个小写字母，优先考虑数组

三、Leetcode15(三数之和)

题目描述

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

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

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

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

题目链接：力扣题目链接

解题思路

怎么保存和/和的元素，还要去重(哈希表不方便)
怎么实现去重(排序)
去重的顺序(先保存第一次结果，再移动元素去重)

方法:双指针法

先排序
遍历i，left,right为双指针
首先做i的剪枝(break)和去重(continue)
当值满足后，做left,right去重(left++/right- -)
返回result

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        # 返回的不是索引,可以排序
        nums.sort()

        result = []
        # 定义i,left,right找三元组
        for i in range(len(nums)):
            left = i + 1
            right = len(nums) - 1
            # 先判断i是否大于0
            if nums[i] > 0:
                break
            # a的去重!!!
            # continue是直接跳过这一次循环
            if i >= 1 and nums[i] == nums[i - 1]:
                continue
            while left < right:
                sum1 = nums[i] + nums[left] + nums[right]
                # 小了left右移
                if sum1 < 0:
                    left += 1
                # 大了right左移
                elif sum1 > 0:
                    right -= 1
                else:
                    result.append([nums[i], nums[left], nums[right]])
                    # b和c去重!!!(相等的时候才需要)
                    # while里面写left < 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

总结

如果不需要返回索引，排序法适合去重
先剪枝，后去重
i的剪枝是break，去重是continue
left/right去重也要防止越界(left<right)，去重完还要更新一个

四、Leetcode18(四数之和)

题目描述

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

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

题目链接：力扣题目链接

解题思路

比三数之和多一个循环(不是多一个指针！)
先剪枝，后去重

方法:双指针法

先排序
遍历i，k，left,right为双指针
一级剪枝+去重
二级剪枝+去重
当值满足后，做left,right去重(left++/right- -)
返回result

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        nums.sort()
        result = []
        n = len(nums)

        # 用i/k遍历,left/right双指针
        for i in range(n):
            # 一级剪枝
            if nums[i] > target and nums[i] > 0 and target > 0:
                break
            if i > 0 and nums[i] == nums[i-1]:  # nums[i]去重
                continue
            for k in range(i+1, n):
                # 二级剪枝
                if nums[i] + nums[k] > target and nums[i] + nums[k] > 0 and target > 0:
                    break
                if k > i+1 and nums[k] == nums[k-1]:  # nums[k]去重
                    continue
                left = k + 1
                right = n - 1

                while left < right:
                    total = nums[i] + nums[k] + nums[left] + nums[right]
                    if total > target:
                        right -= 1
                    elif total < target:
                        left += 1
                    else:
                        result.append([nums[i], nums[k], nums[left], nums[right]])
                        # 对nums[left]和nums[right]去重
                        while left < right and nums[left+1] == nums[left]:
                            left += 1
                        while left < right and nums[right-1] == nums[right]:
                            right -= 1
                        left += 1
                        right -= 1
        return result

总结

思路跟三数之和差不多，只是多了个循环
target可正可负，sort升序，i>0，target>0且i>target才能剪枝
先剪枝，后去重！

心得：坚持到Day7，多回忆一下去重思想，还有剪枝+去重的顺序和细节…

ambitious_Rgr

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫