0212leetcode刷题5道python

71

题目描述：
以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径
请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。

示例：

解答：

class Solution:
    def simplifyPath(self, path: str) -> str:
        stack=[]
        for i in path.split('/'):
            if i not in['','.','..']:
                stack.append(i)
            elif i=='..'and stack:
                stack.pop()
        return "/"+"/".join(stack)

94

题目描述：
给定一个二叉树的根节点 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 inorderTraversal(self, root: TreeNode) -> List[int]:
        stack,res=[],[]
        cur=root
        while stack or cur:
            if cur:
                stack.append(cur)
                cur=cur.left
            else:
                cur=stack.pop()
                res.append(cur.val)
                cur=cur.right
        return res

150

题目描述：
根据 逆波兰表示法，求表达式的值。
有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例：


解答：

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        f1 = lambda a,b:a+b
        f2 = lambda a,b:a-b
        f3 = lambda a,b:a*b
        f4 = lambda a,b:int(a/b)
        maps = {'+':f1,'-':f2,'*':f3,'/':f4}
        stack = []
        for i in tokens:
            if i in maps:
                a = stack.pop()
                b = stack.pop()
                stack.append(maps[i](b,a))
            else:
                i = int(i)
                stack.append(i)
        return stack[-1]

978

题目描述：
当 A 的子数组 A[i], A[i+1], …, A[j] 满足下列条件时，我们称其为湍流子数组：
若 i <= k < j，当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；
或 若 i <= k < j，当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。
也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。
返回 A 的最大湍流子数组的长度。

示例：

解答：

class Solution:
    def maxTurbulenceSize(self, arr: List[int]) -> int:
        N = len(arr)
        up = [1] * N
        down = [1] * N
        res = 1
        for i in range(1, N):
            if arr[i - 1] < arr[i]:
                up[i] = down[i - 1] + 1
            elif arr[i - 1] > arr[i]:
                down[i] = up[i - 1] + 1
            res = max(res, max(up[i], down[i]))
        return res

992

题目描述：
给定一个正整数数组 A，如果 A 的某个子数组中不同整数的个数恰好为 K，则称 A 的这个连续、不一定独立的子数组为好子数组。
（例如，[1,2,3,1,2] 中有 3 个不同的整数：1，2，以及 3。）
返回 A 中好子数组的数目。

示例:

解答：

class Solution:
    def subarraysWithKDistinct(self, A: List[int], K: int) -> int:
        left, right = 0, 0
        res = 0
        N = len(A)

        window = collections.defaultdict(int)  # 用于保留K个不重复数字的窗口
        count = 0   # 用于表示当前[left, right]有多少个不重复数字 

        while right < N:
            if window[A[right]] == 0:
                count += 1
            window[A[right]] += 1
            # 1.当窗口大于K个不重复数字时，left指针右移
            while count > K:
                window[A[left]] -= 1
                if window[A[left]] == 0:
                    count -= 1
                left += 1

            temp = left # 临时指针，这个记录一下对于同一个right，有多少个候选的left也满足条件
            # 2.正好有K个不重复数字时，记录结果
            #   同时用temp指针从left向右移动，看是否依旧满足，满足则res+1
            while count == K:
                res += 1
                window[A[temp]] -= 1
                if window[A[temp]] == 0:
                    count -= 1
                temp += 1

            # 3.将指针和window以及count恢复成原样，以进一步向右移动right做准备
            while temp > left:
                if window[A[temp - 1]] == 0:
                    count += 1
                window[A[temp - 1]] += 1
                temp -= 1
            
            right += 1

        return res