刷Leetcode的第二十一天

序言

今天是刷LT的一天，好好干饭，好好努力，好好加油哦！

给定一个整数 n，返回 n! 结果尾数中零的数量

例子如下：

输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零

输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零

思路是 寻找多少个5 因为0是由5和2构成的 而偶数产生的2肯定比5多，
所以寻找总共有多少个5的倍数

    def trailingZeroes(self, n: int) -> int:
        #遍历寻找多少个5的倍数 
        ans = 0
        while n: 
            ans += n//5 
            n = n//5 
        return ans 

---

22. 括号生成
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

输入：n = 1
输出：["()"]

DFS方法：
如果不考虑是否配对这个问题的话，其实是可以生成很多种可能的，这些可能刚好就满足二叉树
假设n=2的话：

                              ‘’                   
                      /                \
                     (                  )                 
                 /       \           /      \
                ((        ()         )(       ))
               /  \      /   \      /  \       /  \
             (((   (()  ()(  ())   )((  )()   ))(  )))
            / \    /  \  /  \  /  \   /  \  /  \  /  \  /  \
        (((( ((() (()( (()) ...............................

然后，如何要配对成功的话，需要剪掉 一些不满足的树枝，

（1）：当右边的 ) 的数量 大于左边的（ 数量，比如 ()) 。 这就是错误的树枝，需要剪掉 return掉

（2）：左边的 ( 数量 大于 n，也是错误的树枝，比如(((

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        #特殊情况
        if n <= 0: return []

        ans = []

        def dfs(node,left,right):
            # 放弃某些树枝的条件：
            #（1）当右边的 ) 的数量 大于左边的（ 数量，比如 ()) 
            #这就是错误的树枝，需要剪掉 return掉
            #（2）左边的 ( 数量 大于 n，也是错误的树枝，比如(((
            if right > left or left > n: return 

            #那么什么是正确的树枝呢？当过滤掉上面的条件之后
            #长度等于 n*2 的即可返回了 
            if len(node)==n*2:
                ans.append(node)
                return 

            dfs(node + '(', left +1, right)
            dfs(node+')', left, right +1)
        
        dfs('',0,0)
        return ans 

---

84

84：给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大i’8面积

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

例子如下

输入: [2,1,5,6,2,3]
输出: 10

（1）暴力法
思路是对于每个位置上都计算这个位置的最大矩形面积是多少，最后取最大值。
而对于 某个位置最大面积的计算方式：高度不难理解，宽度的计算方式如下：
宽度 = 往右取 比该点高度低的最近的位置 - 往右取 比该点高度低的最近的位置 - 1

def largestRectangleArea(heights):
	N = len(heights)
	ans = []
	
	for i in range(N):
		left  = i 
		right = i 
		while left >=0 and heights[left] >= heights[i]:left -=1 
		while right < N and heights[right] >= heights[i]: rigth += 1
		ans.append(heights[i]*(right-left-1))	
	return max(ans)			
		

但这个这是一个时间复杂度为 O(n^2)，时间限制会超过，所以此方法不行。
（2）用栈方法
求每个位置的往右可以延伸的最大面积。即以这个位置为高度，寻找最大的面积

    def largestRectangleArea(self, heights: List[int]) -> int:
        stack = []
        heights.append(0)
        heights.insert(0,0)      
        ans = 0
        for i in range(len(heights)):
            while stack and heights[i] < heights[stack[-1]]:
                cur = stack.pop()
                #遇到了小的数，则可以计算出来最大面积，然后pop掉
                ans = max(ans, (i - stack[-1] - 1) * heights[cur])
            stack.append(i)
        return ans

---

85. 最大矩形
给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积

输入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],
["1","1","1","1","1"],["1","0","0","1","0"]]
输出：6
解释：最大矩形如上图所示

输入：matrix = []
输出：0

输入：matrix = [["1"]]
输出：1

这里的思路：
对于每一层，每一列都要算上一次最大矩阵，用上84的方法
比如 例1:
对于第一层，数组为 [1,0,1,0,0]， 计算最大矩阵面积
对于第二层，数组为[2,0,2,1,1], 计算最大矩阵面积
对于第三层，数组为 [3,1,3,2,2], 计算最大矩阵面积
对于第四层，数组为[4,0,0,3,0], 计算最大矩阵面积
这里的要点是 当这一层出现0，则相对应的我数值则为0，如果连续出现1，则累加。

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        if not matrix:return 0
        row = len(matrix)
        col = len(matrix[0])
        ans = 0 

        cur = [0]*col
        for i in range(row):
            for j in range(col):
                if matrix[i][j] == '1': cur[j] += 1 
                else: cur[j] = 0 
                
			#开始计算最大面积
            nums = cur 
            stack = []
            nums = [0] + nums + [0]
            for i in range(len(nums)):
                while stack and nums[i] < nums[stack[-1]]:
                    index = stack.pop()
                    ans = max(ans, nums[index]*(i-stack[-1]-1))
                stack.append(i)
        return ans