LeetCode：每日一题【第四周】

星空皓月

已于 2022-08-28 20:26:35 修改

阅读量183

点赞数

分类专栏：算法刷题库文章标签： leetcode 深度优先算法

于 2022-08-22 15:13:47 首次发布

本文链接：https://blog.csdn.net/qq_45249273/article/details/126466574

版权

算法刷题库专栏收录该内容

71 篇文章 11 订阅

订阅专栏

8.22 ~ 8.28 尽量坚持刷力扣的每日一题，锻炼大脑思维。更新中~~

655. 输出二叉树【DFS + 模拟】

先递归求二叉树高度，然后再根据题目要求来模拟递归求答案数组。

AC代码

class Solution:
    def printTree(self, root: Optional[TreeNode]) -> List[List[str]]:
        def calDepth(rt: Optional[TreeNode]) -> int:
            if rt == None:
                return 0
            else:
                return max(calDepth(rt.left), calDepth(rt.right)) + 1
        height = calDepth(root) - 1
        
        m = height + 1
        n = 2 ** m - 1
        ans = [[''] * n for _ in range(m)] # 构造一个m * n大小的数组
        def dfs(rt: Optional[TreeNode], r: int, c: int) -> None:
            ans[r][c] = str(rt.val)
            if rt.left:
                dfs(rt.left, r + 1, c - 2 ** (height - r - 1))
            if rt.right:
                dfs(rt.right, r + 1, c + 2 ** (height - r - 1))
        
        dfs(root, 0, (n - 1) // 2)
        return ans

782. 变为棋盘

有难度，待更

1460. 通过翻转子数组使两个数组相等

思路

如果两个数组值都一样，而顺序不一样，可以通过无限次的翻转得到一样的数组，反之，则不能。于是只需要比较两个数组值是否相同即可。

AC代码

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        target.sort()
        arr.sort()
        return target == arr

658. 找到 K 个最接近的元素【自定义排序】

思路

讲数组按照abs(arr[i] -v)进行从小到大排序即为最接近x的k个元素，之后在对前k个数排序即为升序。

AC代码

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        arr.sort(key=lambda v: abs(v - x))
        return sorted(arr[:k])

1464. 数组中两元素的最大乘积【模拟】

思路

遍历数组，找最大值和次大值。

AC代码

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        # 记录最大x和次大值y
        x, y = nums[0], nums[1]
        if x < y:
            x, y = y, x
        
        n = len(nums)
        for i in range(2, n):
            if y <= nums[i] <= x:
                y = nums[i]
            if x <= nums[i]:
                y = x
                x = nums[i]
        return (x - 1) * (y - 1)

662. 二叉树最大宽度【BFS】

思路

遍历数组找到同层中最大的编号和最小的编号，两者相减再加1就是二叉树的最大宽度。

AC代码

class Solution:
    def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        ans = 1
        stack = [[root, 1]]
        while stack:
            tmp = []
            for node, pos in stack:
                if node.left:
                    tmp.append([node.left, 2 * pos])
                if node.right:
                    tmp.append([node.right, 2 * pos + 1])

            ans = max(ans, stack[-1][1] - stack[0][1] + 1)
            stack = tmp

        return ans

793. 阶乘函数后 K 个零

在做这个题之前可以做做它的低阶版本。172. 阶乘后的零

思路（172）

首先统计阶乘函数有多少个零，我们发现2 * 5 = 10 含一个零，而每个5个数都会出现一个2的倍数和一个5的倍数，这样遍会再多一个零，例如10！= 2*… * 5 * 6 * …* 10 = 10 * 6 *10 = …00就有两个0。于是我们只需要统计有多少个5的质因子就行。

AC代码

class Solution:
    def trailingZeroes(self, n: int) -> int:
        # 我们知道2 * 5 = 10就有一个零，而没各5位相乘就会出现5的倍数，出现5的倍数之前还会出现2的倍数，所以我们只需要统计有多少个5的相乘就能得到有多少个零。
        ans = 0
        while n:
            n //= 5
            ans += n
        return ans

思路（793）

本题是上面一个题的升级版，现已经知道怎样算阶乘函数有多少个零，而这个函数算出来的值是非递减的。所以可以用二分来查找f(k + 1) - f(k)就满足有多少个满足阶乘函数为k个零的数。

AC代码

class Solution:
    def preimageSizeFZF(self, k: int) -> int:
        def cal_0(n: int) -> int:
            ans = 0
            while n:
                n //= 5
                ans += n
            return ans
        
        def binarySearch(k: int) -> int:
            return  bisect_left(range(5 * k), k, key = cal_0)
        
        return binarySearch(k + 1) - binarySearch(k)