leetcode刷题记录1131-1140 python版

前言

继续leetcode刷题生涯
这里记录的都是笔者觉得有点意思的做法
参考了好几位大佬的题解，感谢各位大佬

1131. 绝对值表达式的最大值

class Solution:
    def maxAbsValExpr(self, arr1: List[int], arr2: List[int]) -> int:
        res = 0
        for i in range(len(arr1)-1):
            for j in range(i+1, len(arr1)):
                res = max(abs(arr1[i]-arr1[j]) + abs(arr2[i]-arr2[j]) + abs(i-j), res)
        return res
# 曼哈顿距离
class Solution:
    def maxAbsValExpr(self, arr1: List[int], arr2: List[int]) -> int:
        n = len(arr1)
        res = 0
        # 枚举四个方向
        for dx, dy in [(1, 1), (-1, 1), (1, -1), (-1, -1)]:
            maxv = -4000000
            minv = 4000000
            # 计算当前方向上的曼哈顿距离最小值和最大值
            for i in range(n):
                maxv = max(maxv, arr1[i] * dx + arr2[i] * dy + i)
                minv = min(minv, arr1[i] * dx + arr2[i] * dy + i)
            # 更新答案
            res = max(res, maxv - minv)
        return res

1137. 第 N 个泰波那契数

class Solution:
    def tribonacci(self, n: int) -> int:
        if n == 0: return 0
        if n == 1 or n == 2: return 1
        a, b, c = 0, 1, 1
        for i in range(n-2):
            a, b, c = b, c, a+b+c
        return c

1138. 字母板上的路径

class Solution:
    def alphabetBoardPath(self, target: str) -> str:
        l = {
    
    'a': [0, 0], 'b': [0, 1], 'c': [0, 2], 'd': [0, 3], 'e': [0, 4], 'f': [1, 0], 'g': [1, 1], 'h': [1, 2], 'i': [1, 3], 'j': [1, 4], 'k': [2, 0], 'l': [2, 1], 'm': [2, 2], 'n': [2, 3], 'o': [2, 4], 'p': [3, 0], 'q': [3, 1], 'r': [3, 2], 's': [3, 3], 't': [3, 4], 'u': [4, 0], 'v': [4, 1], 'w': [4, 2], 'x': [4, 3], 'y': [4, 4], 'z': [5, 0]}
        res, start = '', 'a'
        for end in target:
            ax, ay, bx, by = l[start] + l[end]
            tmp = ('D' * (bx - ax) if bx > ax else 'U' * (ax - bx)) + ('R' * (by - ay) if by > ay else 'L' * (ay - by))
            if end == 'z' and ay > 0: tmp = tmp[1:] + tmp[0]
            res += tmp + '!'
            start = end
        return res

1139. 最大的以 1 为边界的正方形

class Solution:
    def largest1BorderedSquare(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        #l表示点i,j左侧连续0的个数，u表示i,j上方连续0的个数
        l = [[0 for _ in range(n)] for _ in range(m)]
        u = [[0 for _ in range(n)] for _ in range(m)]
        maxLen = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j]==0: continue
                l[i][j], u[i][j] = 1, 1
                if i > 0:
                    u[i][j] += u[i-1][j]
                if j > 0:
                    l[i][j] += l[i][j-1]
                for k in range(min(u[i][j], l[i][j]), 0, -1):
                    if k > maxLen and u[i][j-k+1] >= k and l[i-k+1][j] >= k:
                        maxLen = k
 
        return maxLen**2

1140. 石子游戏 II

class Solution:
    def stoneGameII(self, piles: List[int]) -> int:
        # 数据规模与记忆化
        n, memo = len(piles), dict()
        
        # s[i] 表示第 i 堆石子到最后一堆石子的总石子数
        s = [0] * (n + 1)
        for i in range(n - 1, -1, -1):
            s[i] = s[i + 1] + piles[i]
            
        # dfs(i, M) 表示从第 i 堆石子开始取，最多能取 M 堆石子所能得到的最优值
        def dfs(i, M):
            # 如果已经搜索过，直接返回
            if (i, M) in memo:
                return memo[(i, M)]
            # 溢出拿不到任何石子
            if i >= n:
                return 0
            # 如果剩余堆数小于等于 2M， 那么可以全拿走
            if i + M * 2 >= n:
                return s[i]
            # 枚举拿 x 堆的最优值
            best = 0
            for x in range(1, M * 2 + 1):
                # 剩余石子减去对方最优策略
                best = max(best, s[i] - dfs(i + x, max(x, M)))
            # 记忆化
            memo[(i, M)] = best
            return best
        
        return dfs(0, 1)