NeetCode刷题第五天(2024.12.08 )

Exceptional_1

已于 2024-12-11 20:19:35 修改

阅读量803

点赞数 23

分类专栏： NeetCode 150 文章标签： python

于 2024-12-08 21:49:02 首次发布

本文链接：https://blog.youkuaiyun.com/Exceptional_1/article/details/144322071

版权

NeetCode 150 专栏收录该内容

21 篇文章

订阅专栏

文章目录

028 Group Anagrams 组字谜
029 Top K Frequent Elements 前 K 个频繁元素
030 Encode and Decode Strings 编码和解码字符串
031 Products of Array Except Self 除 Self 之外的数组的乘积
032 Valid Sudoku 有效数独
033 Longest Consecutive Sequence 最长连续序列
034 Two Integer Sum II 两个整数和 II
035 3Sum 3总和

028 Group Anagrams 组字谜

给定一个字符串数组strs ，将所有字谜词分组到子列表中。您可以按任何顺序返回输出。
字谜词是一个字符串，其中包含与另一个字符串完全相同的字符，但字符的顺序可以不同。

示例1：
Input: strs = ["act","pots","tops","cat","stop","hat"]
Output: [["hat"],["act", "cat"],["stop", "pots", "tops"]]

解题1： 哈希表
遍历每个字符串，并用哈希表存储字符串中每个字母出现的次数

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        # list 作为 defaultdict 的参数意味着，如果你访问一个不存在的键，
        # defaultdict 会自动创建一个空的列表 [] 作为该键的默认值。
        # defaultdict 是 Python 标准库 collections 模块中的一个类，继承自 dict，用来创建一个字典，
        # 当访问不存在的键时，它会自动为该键提供一个默认值，而不抛出 KeyError 异常。
        res = defaultdict(list)

        for s in strs:
            count = [0] * 26 # a...z
            for c in s:
                # 这里用ASCII码来组为键值计数每个单词出现的次数
                count[ord(c) - ord("a")] += 1
            # 字典的键值不能是列表的形式，所以强制转换为元组，元组是不可变的
            res[tuple(count)].append(s)
        return res.values()

时间复杂度: $O (m * n)$ ，m是给定的单词数量，n是每个字符串的平均长度
空间复杂度: $O (m)$

029 Top K Frequent Elements 前 K 个频繁元素

给定一个整数数组nums和一个整数k ，返回数组中k个最常见的元素。
生成的测试用例使得答案始终是唯一的。
您可以按任何顺序返回输出。

示例1：
Input: nums = [1,2,2,3,3,3], k = 2
Output: [2,3]

解题1： 桶排序
桶排序（Bucket Sort）是一种基于分布的排序算法，它将输入元素分到有限数量的桶里，再对每个桶内的元素进行排序，最后将桶内的元素按顺序合并，得到最终的排序结果。桶排序特别适合于输入数据均匀分布的情况。
在这里插入图片描述
这里我们设置列表为数字第一行为可能出现的次数，值则为列表中出现该次数的数字，也是列表形式，因为可能存在多个数字出现相同次数的情况
因为原列表的长度是6，所以某个数字可能出现的最多次数也只可能是6，故计算列表的长度也设置为6

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        count = dict()
        freq = [[] for i in range(len(nums) + 1)]
        # 记录每个数字出现的次数
        for num in nums:
            count[num] = count.get(num, 0) + 1
        # 用一个列表来记录出现次数为c的数字n都有哪些
        for n, c in count.items():
            freq[c].append(n)
        
        res = []
        # 注意，遍历是从0开始的，所以 这里需要减一
        # 从后往前遍历，就可以从出现次数最多的数字开始了
        for i in range(len(freq)-1, 0, -1):
            for n in freq[i]:
                res.append(n)n
                if len(res)== k:
                    return res

时间复杂度: $O (n)$
空间复杂度: $O (n)$

030 Encode and Decode Strings 编码和解码字符串

设计一种算法将字符串列表编码为单个字符串。然后将编码后的字符串解码回原始字符串列表。
请实现encode和decode

示例1：
Input: ["neet","code","love","you"]
Output:["neet","code","love","you"]

解题1：

class Solution:

    def encode(self, strs: List[str]) -> str:
        res = ""
        for s in strs:
            # 这里注意需要把int转为str类型
            # # 用来记录字符串长度记录结束
            res += str(len(s)) + "#" + s
        return res

    def decode(self, s: str) -> List[str]:
        res, i = [], 0
        while i < len(s):
            j = i
            while s[j] != "#":
                j += 1
            length = int(s[i:j])
            res.append(s[j+1: j+1+length])
            i = j+1+length
        return res

时间复杂度: $O (m)$ ，m 是所有字符串的长度之和
空间复杂度: $O (1)$

031 Products of Array Except Self 除 Self 之外的数组的乘积

给定一个整数数组nums ，返回一个数组output ，其中output[i]是nums中除nums[i]之外的所有元素的乘积。
每个产品都保证适合32 位整数。
追问：你能用时间复杂度为O(n) 解决这个问题吗？不使用除法。

示例1：
IInput: nums = [1,2,4,6]
Output: [48,24,12,8]

解题1：
在这里插入图片描述
在前缀数组中记录数组中第i个元素前面数的乘积，在后缀数组中记录数组中第i个元素后面数的乘积，输出则是第i个元素前面乘积和后面乘积的积

但其实我们可以节约内存，不使用额外的两个前缀和后缀数组来存储中间值，只需要遍历两边数组，直接把结果记录到output数组中即可。

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        res = [1] * (len(nums))

        prefix = 1
        for i in range(len(nums)):
            res[i] = prefix
            prefix *= nums[i]

        postfix = 1
        # 这里需要记住，当列表从后往前走的时候，索引一定要减1
        for i in range(len(nums)-1, -1, -1):
            res[i] *= postfix
            postfix *= nums[i]
        return resn

时间复杂度: $O (n)$
空间复杂度: $O (1)$ ，因为输出数组不在空间分析考虑之内

032 Valid Sudoku 有效数独

您将获得一块9 x 9数独board 。如果遵循以下规则，数独板是有效的：

每行必须包含数字1-9 ，且不能重复。
每列必须包含数字1-9 ，且不能重复。
网格的九个3 x 3子框中的每一个都必须包含数字1-9 ，且不能重复。

如果数独板有效则返回true ，否则返回false

示例1：
Input: board = 
[["1","2",".",".","3",".",".",".","."],
 ["4",".",".","5",".",".",".",".","."],
 [".","9","8",".",".",".",".",".","3"],
 ["5",".",".",".","6",".",".",".","4"],
 [".",".",".","8",".","3",".",".","5"],
 ["7",".",".",".","2",".",".",".","6"],
 [".",".",".",".",".",".","2",".","."],
 [".",".",".","4","1","9",".",".","8"],
 [".",".",".",".","8",".",".","7","9"]]
Output: true

解题1： 哈希表
这里的行列使用哈希集比较容易想到，但是对于3*3的网格，我们可以把一个小方格内的坐标映射到相同的值，这样就方便构造哈希集
在这里插入图片描述

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        cols = collections.defaultdict(set)
        rows = collections.defaultdict(set)
        squares = collections.defaultdict(set) # key = (r/3, c/3)

        for r in range(9):
            for c in range(9):
                if board[r][c] == ".":
                    continue
                if (board[r][c] in cols[r] or
                    board[r][c] in rows[c] or 
                    board[r][c] in squares[(r//3, c//3)]):
                    return False
                cols[r].add(board[r][c])
                rows[c].add(board[r][c])
                squares[(r//3, c//3)].add(board[r][c])
        return True

时间复杂度: $O(n^2)$
空间复杂度: $O(n^2)$

033 Longest Consecutive Sequence 最长连续序列

给定一个整数数组nums ，返回可以形成的最长连续元素序列的长度。
连续序列是一个元素序列，其中每个元素都比前一个元素恰好大1 。原始数组中的元素不必是连续的。
您必须编写一个在O(n)时间内运行的算法。

示例1：
Input: nums = [2,20,4,10,3,4,5]
Output: 4

解题1： 哈希集
遍历每个数，如果这个数的前一个数字不在集合中，就说明它是开始，然后找他后面的数字有多少个在集合中
在这里插入图片描述

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        setnums = set(nums)
        longest = 0

        for num in nums:
            if (num-1) not in setnums:
                length = 0
                while (length+num) in setnums:
                    length += 1
                longest = max(longest, length)
        return longest

时间复杂度: $O (n)$
空间复杂度: $O (n)$

034 Two Integer Sum II 两个整数和 II

给定一个按非递减顺序排序的整数numbers 。
返回两个数字[index1, index2]的索引，使它们相加达到给定的目标数字target和index1 < index2 。请注意， index1和index2不能相等，因此您不能两次使用相同的元素。
总会有一个有效的解决方案。
您的解决方案必须使用O(1) 额外的空间。

示例1：
Input: numbers = [2,7,11,15], target = 9
Output: [1.2]

解题1：
在这里插入图片描述
在这里我们可以设置两个指针，一个从后往前，一个从前往后。因为数组是已经排序的，所以如果两个指针和大于目标值，就把右指针往左移，如果小于目标值就左指针往右移

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        l, r = 0, len(numbers) - 1
        while l < r:
            if numbers[l] + numbers[r] > target:
                r -= 1
            elif numbers[l] + numbers[r] < target:
                l += 1
            # 剩下的情况就是两个数的和等于target
            else:
                # 记住这里需要加1，从示例中可以知道返回的索引是从1开始而不是0
                return [l+1, r+1]

时间复杂度: $O (n)$
空间复杂度: $O (1)$

035 3Sum 3总和

给定一个整数数组nums ，返回所有三元组[nums[i], nums[j], nums[k]]其中 nums[i] + nums[j] + nums[k] == 0 ，并且索引i 、 j和k都是不同的。
输出不应包含任何重复的三元组。您可以按任何顺序返回输出和三元组。

示例1：
Input: nums = [-1,0,1,2,-1,-4]
Output:[[-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] 。

解题1： 哈希表
遍历每个字符串，并用哈希表存储字符串中每个字母出现的次数

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        res = []
        nums.sort()

        for i, a in enumerate(nums):
            if i > 0 and nums[i-1] == a:
                continue
            l, r = i+1, len(nums)-1
            while l < r:
                if a+nums[l]+nums[r] > 0:
                    r -= 1
                elif a+nums[l]+nums[r] < 0:
                    l += 1
                else:
                    res.append([a, nums[l], nums[r]])
                    l += 1
                    while l < r and nums[l] == nums[l-1]:
                        l += 1
        return res