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

最新推荐文章于 2025-12-31 21:25:26 发布

原创最新推荐文章于 2025-12-31 21:25:26 发布 · 945 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#算法

代码随想录算法训练营二刷记录专栏收录该内容

23 篇文章

订阅专栏

454.四数相加II

本题算是好做的，因为有4个相同大小的数组，且位置也可以取相同。可以将4数之和破开成两两的和。

第一遍实现的时候超时了，将nums1和nums2的和求出来之后又遍历和数组去找nums3和nums4中符合要求的，这里遍历和数组后复杂度变成了 $n^3$ 。后面改进后分别记录了nums1、nums2的和以及nums3、nums4的和，然后Counter方法拿到了两两和字典，再使用乘法原理和加法原理计算方法总数。

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        from collections import Counter
        n = len(nums1)
        res = 0
        targets1 = []
        for i in range(n):
            for j in range(n):
                targets1.append(nums1[i] + nums2[j])
        targets2 = []
        for i in range(n):
            for j in range(n):
                targets2.append(nums3[i] + nums4[j])
        targets1 = Counter(targets1)
        targets2 = Counter(targets2)
        for k, v in targets1.items():
            if -k in targets2:
                res += (v * targets2[-k])
        return res

这样其实速度还可以，但是实际上时间复杂度和空间复杂度都有优化的空间。后面又进行一版修改，使用defaultdict以及get()方法，两次嵌套循环即可得到结果。

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        from collections import defaultdict
        res = 0
        targets = defaultdict(lambda: 0)
        for num1 in nums1:
            for num2 in nums2:
                targets[-num1-num2] += 1
        for num3 in nums3:
            for num4 in nums4:
                res += targets.get(num3 + num4,0)
        return res

383. 赎金信

开一个26长的的数组做哈希。

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        letters = [0] * 26
        for letter in magazine:
            letters[ord(letter) - ord('a')] += 1
        for letter in ransomNote:
            letters[ord(letter) - ord('a')] -= 1
        return all(x >= 0 for x in letters)

或者使用强大的collections.Counter, 他生来就是干这个的！

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        from collections import Counter
        return not Counter(ransomNote) - Counter(magazine)

15. 三数之和

这题似乎主要难点在不能重复，先写一个会重复的双指针实现：

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        for i in range(len(nums) - 2):
            j = i + 1
            k = len(nums) - 1
            target = -nums[i]
            while j < k:
                if nums[j] + nums[k] == target:
                    res.append([nums[i], nums[j], nums[k]])
                    j += 1
                    k -= 1
                elif nums[j] + nums[k] > target:
                    k -= 1
                else:
                    j += 1
        return res

明显这段代码会造成重复输出，分析重复原因：

固定 $i$ 后， $j$ 和 $k$ 移动时重复。
$i$ 移动时也会重复，具体地，如果nums[ $i$ ]和nums[ $i - 1$ ]相等，意味着如果 $i - 1$ 的结果已经遍历过了（记录过结果了，这里很重要，纠结debug很久，后面阅读Carl的题解时也发现重点提到了这里），那么移动到 $i$ 后并不会增加其他的结果。
整理后代码如下：

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        for i in range(len(nums) - 2):
            if res and nums[i] == nums[i - 1]:
                continue
            j = i + 1
            k = len(nums) - 1
            target = -nums[i]
            while j < k:
                if nums[j] + nums[k] == target:
                    res.append([nums[i], nums[j], nums[k]])
                    while j < k and nums[j + 1] == nums[j]:
                        j += 1
                    while j < k and nums[k - 1] == nums[k]:
                        k -= 1
                    j += 1
                    k -= 1
                elif nums[j] + nums[k] > target:
                    k -= 1
                else:
                    j += 1
        return res

18. 四数之和

有了三数之和的经验，这题相当简单

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        res = []
        for a in range(len(nums) - 3):
            if a > 0 and nums[a] == nums[a - 1]:
                continue
            for b in range(a + 1, len(nums) - 2, 1):
                if b > a + 1 and nums[b] == nums[b - 1]:
                    continue
                cur = target - nums[a] - nums[b]
                c = b + 1
                d = len(nums) - 1
                while c < d:
                    if nums[c] + nums[d] == cur:
                        res.append([nums[a], nums[b], nums[c], nums[d]])
                        while c < d and nums[c] == nums[c + 1]:
                            c += 1
                        while c < d and nums[d] == nums[d - 1]:
                            d -= 1
                        c += 1
                        d -= 1
                    elif nums[c] + nums[d] > cur:
                        d -= 1
                    else:
                        c += 1
        return res