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