0301leetcode刷题5道python

124

题目描述;
路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 root ，返回其 最大路径和 。

示例：

解答：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxPathSum(self, root: TreeNode) -> int:
        self.max_sum = -sys.maxsize - 1

        def scan(root):
            if root is None:
                return -sys.maxsize - 1
            left = scan(root.left)
            right = scan(root.right)
            self.max_sum = max(self.max_sum, root.val + left + right, left, right) # 情况1,5,6，不累加直接放变量里暂存
            return max(root.val, root.val + left, root.val + right)  # 情况2,3,4 ，累加需要递归

        new_max = scan(root)
        return max(self.max_sum, new_max)  # 两类情况再求最大

303

题目描述：
给定一个整数数组 nums，求出数组从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点。
实现 NumArray 类：
NumArray(int[] nums) 使用数组 nums 初始化对象
int sumRange(int i, int j) 返回数组 nums 从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点（也就是 sum(nums[i], nums[i + 1], … , nums[j])）

示例：

解答：

class NumArray:

    def __init__(self, nums: List[int]):
        self.nums=nums


    def sumRange(self, i: int, j: int) -> int:
        return sum(self.nums[i:j+1])



# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# param_1 = obj.sumRange(i,j)

1266

题目描述：
平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi] 。请你计算访问所有这些点需要的 最小时间（以秒为单位）。
你需要按照下面的规则在平面上移动：
每一秒内，你可以：
沿水平方向移动一个单位长度，或者
沿竖直方向移动一个单位长度，或者
跨过对角线移动 sqrt(2) 个单位长度（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
必须按照数组中出现的顺序来访问这些点。
在访问某个点时，可以经过该点后面出现的点，但经过的那些点不算作有效访问。

示例：

解答：

class Solution:
    def minTimeToVisitAllPoints(self, points: List[List[int]]) -> int:
        res = 0
        for i in range(1,len(points)):
            res += max(abs(points[i][0]-points[i-1][0]),abs(points[i][1]-points[i-1][1]))
        return res

1275

题目描述;
A 和 B 在一个 3 x 3 的网格上玩井字棋。
井字棋游戏的规则如下：
玩家轮流将棋子放在空方格 (" ") 上。
第一个玩家 A 总是用 “X” 作为棋子，而第二个玩家 B 总是用 “O” 作为棋子。
“X” 和 “O” 只能放在空方格中，而不能放在已经被占用的方格上。
只要有 3 个相同的（非空）棋子排成一条直线（行、列、对角线）时，游戏结束。
如果所有方块都放满棋子（不为空），游戏也会结束。
游戏结束后，棋子无法再进行任何移动。
给你一个数组 moves，其中每个元素是大小为 2 的另一个数组（元素分别对应网格的行和列），它按照 A 和 B 的行动顺序（先 A 后 B）记录了两人各自的棋子位置。
如果游戏存在获胜者（A 或 B），就返回该游戏的获胜者；如果游戏以平局结束，则返回 “Draw”；如果仍会有行动（游戏未结束），则返回 “Pending”。
你可以假设 moves 都 有效（遵循井字棋规则），网格最初是空的，A 将先行动。

示例：

解答：

class Solution:
    def tictactoe(self, moves: List[List[int]]) -> str:
        a=['Pending']*9
        for i in range(len(moves)):
            if i%2==0:
                a[moves[i][0]*3+moves[i][1]]='A'
            else:
                a[moves[i][0]*3+moves[i][1]]='B'

        if a[0]==a[1]==a[2]:
            return a[0]
        elif a[3]==a[4]==a[5]:
            return a[3]
        elif a[6]==a[7]==a[8]:
            return a[6]
        elif a[0]==a[4]==a[8]:
            return a[0]
        elif a[2]==a[4]==a[6]:
            return a[2]
        elif a[0]==a[3]==a[6]:
            return a[0]
        elif a[1]==a[4]==a[7]:
            return a[1]
        elif a[2]==a[5]==a[8]:
            return a[2]
        elif 'Pending' not in a:
            return 'Draw'
        else:
            return 'Pending'

1331

题目描述：
给你一个整数数组 arr ，请你将数组中的每个元素替换为它们排序后的序号。
序号代表了一个元素有多大。序号编号的规则如下：
序号从 1 开始编号。
一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。
每个数字的序号都应该尽可能地小。

示例：

解答：

class Solution:
    def arrayRankTransform(self, arr: List[int]) -> List[int]:
        arr1=sorted(set(arr))
        d={}
        for i,v in enumerate(arr1,1):
            d[v]=i
        return [d[i] for i in arr]