目录

1.最简分数（公约数问题）

字符串前加r'', b'', u'', f'' 的含义

2.最大正方形

3.最小路径和

4. 杨辉三角

官方题解：（学学滚动数组的用法） 

---

1.最简分数（公约数问题）

1447. 最简分数

给你一个整数 n ，请你返回所有 0 到 1 之间（不包括 0 和 1）满足分母小于等于  n 的 最简 分数 。分数可以以 任意 顺序返回。

示例 1：

输入：n = 2
输出：["1/2"]
解释："1/2" 是唯一一个分母小于等于 2 的最简分数。

示例 2：

输入：n = 3
输出：["1/2","1/3","2/3"]

示例 3：

输入：n = 4
输出：["1/2","1/3","1/4","2/3","3/4"]
解释："2/4" 不是最简分数，因为它可以化简为 "1/2" 。

个人题解：

利用小数判断
class Solution:
    def simplifiedFractions(self, n: int) -> List[str]:
        if n == 1:
            return []
        ret = []
        temp = set()
        for i in range(2, n+1):
            j = 1
            while j < i:
                if j/i not in temp:  # 如果temp里面没有，就是最简
                    temp.add(j/i)
                    ret.append("%d/%d" % (j, i))
                j += 1
        return ret

官方题解：

# 官方题解
class Solution:
    def simplifiedFractions(self, n: int) -> List[str]:
        return [f"{numerator}/{denominator}" for denominator in range(2, n + 1) for numerator in range(1, denominator) if gcd(denominator, numerator) == 1]
# f"{}" 相当于格式字符串，类似于”{}“.format() 说白了就是在{}中可以填入python表达式
# gcd() 寻找最大公约数

小tip 输出指定有效数字的浮点数.2f

import time
t0 = time.time()
time.sleep(1)
name = 'processing'
print(f'{name} done in {time.time() - t0:.2f} s')
a = 3
print("%.2f" % a)

字符串前加r'', b'', u'', f'' 的含义

python中 r'', b'', u'', f'' 的含义_Jiashilin-程序员宅基地_python r

2.最大正方形

221. 最大正方形

难度中等1021

在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。

示例 1：

输入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
输出：4

示例 2：

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

示例 3：

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

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 300
• matrix[i][j] 为 '0' 或 '1'

个人题解：

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        def judge(num):
            ret = 0
            for k in range(1, num+1):
                if int(matrix[i - k][j]) == 0 or int(matrix[i][j-k]) == 0:
                    break
                else:
                    ret += 1
            return ret
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0
        row, column = len(matrix), len(matrix[0])
        dp = [[0 for _ in range(column)] for _ in range(row)]
        max_value = 0
        for i in range(row):
            for j in range(column):
                dp[i][j] = int(matrix[i][j])
                if i > 0 and j > 0:
                    temp = judge(dp[i-1][j-1])
                    if dp[i][j] and temp:
                        dp[i][j] += temp
                if dp[i][j] > max_value:
                    max_value = dp[i][j]
        return max_value**2
        # return max([max(i) for i in dp])**2

他人题解：

# 内存最优
class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        curr = 0
        row = len(matrix)
        col = len(matrix[0])

        for i in range(row):
            for j in range(col):
                matrix[i][j] = int(matrix[i][j])
                if matrix[i][j] == 1:
                    curr = 1

        for i in range(1, row):
            for j in range(1, col):
                if matrix[i][j] == 1:
                    matrix[i][j] = min(matrix[i-1][j], matrix[i][j-1], matrix[i-1][j-1]) + 1
                    curr = max(curr, matrix[i][j])

        return curr ** 2

# 时间最优
class Solution:
    def maximalSquare(self, M: List[List[str]]) -> int:
        for i, j in product(range(len(M)), range(len(M[0]))):
            M[i][j] = 0 if M[i][j] == '0' else (1 + (0 if 0 in (i, j) else min(M[i - 1][j], M[i - 1][j - 1], M[i][j - 1], )))
        return max(chain(*M)) ** 2

小结：对子问题的分析有点问题，对于该题的目标正方形来说，其转移方程是

matrix[i][j] = min(matrix[i-1][j], matrix[i][j-1], matrix[i-1][j-1]) + 1

3.最小路径和

力扣https://leetcode-cn.com/problems/minimum-path-sum/

# 个人题解
class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        dp = []
        for i in range(len(grid)):
            dp.append([-1 for _ in range(len(grid[0]))])
            for j in range(len(grid[0])):
                if i == 0 and j == 0:
                    dp[i][j] = grid[i][j]
                elif i == 0 or j == 0:
                    if i == 0:
                        dp[i][j] = dp[i][j-1] + grid[i][j]
                    else:
                        dp[i][j] = dp[i-1][j] + grid[i][j]
                else:
                    dp[i][j] = min(dp[i][j-1], dp[i-1][j]) + grid[i][j]
        return dp[len(grid)-1][len(grid[0])-1]


# 精彩算法
class Solution1:
    def minPathSum(self, grid):
        dp = [float('inf')] * (len(grid[0])+1)  # float("inf")----无穷大的数
        dp[1] = 0
        for row in grid:
            for idx, num in enumerate(row):
                dp[idx + 1] = min(dp[idx], dp[idx + 1]) + num
        return dp[-1]
# 因为在计算时只需正上方位置的数和左边的数，所以该算法只用一个一维数组来储存，dp[idx]相当于左边的数，dp[idx+1]相当于正上方的数

4. 杨辉三角

个人题解：

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        ret = []
        for i in range(1, numRows+1):
            j = 0
            ret.append([])
            while j < i:
                if j == 0 or j == i-1:
                    ret[i-1].append(1)
                else:
                    ret[i-1].append(ret[i-2][j-1]+ret[i-2][j])
                j = j + 1
        return ret


# 输出杨辉三角的最后一行，尽可能的优化空间复杂度（滚动数组）
class Solution:
    def getRow(self, rowIndex: int) -> List[int]:
        temp = []
        ret = []
        for i in range(1, rowIndex+2):
            j = 0
            ret = []
            while j < i:
                if j == 0 or j == i-1:
                    ret.append(1)
                else:
                    ret.append(temp[j-1]+temp[j])

                j = j + 1
            temp = ret.copy()  # 列表要深拷贝
        return ret

官方题解：（学学滚动数组的用法） 

倒着计算时，在row[j] =row[j] + row[j - 1]中，等式右边相当于上一行第i项加上第i-1项

如果不倒着计算，则会覆盖掉