917. 仅仅反转字母
- 题目难度
Easy
给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。
示例 1：
输入："ab-cd"
输出："dc-ba"
示例 2：
输入："a-bC-dEf-ghIj"
输出："j-Ih-gfE-dCba"
示例 3：
输入："Test1ng-Leet=code-Q!"
输出："Qedo1ct-eeLg=ntse-T!"
提示：
S.length <= 10033 <= S[i].ASCIIcode <= 122-
S中不包含\or"
思路：
双指针从两端往中间遍历，如果是字母就交换指针指向的内容，如果不是字母就跳过。
时间复杂度
空间复杂度
代码：
class Solution:
def reverseOnlyLetters(self, S):
"""
:type S: str
:rtype: str
"""
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
s = list(S)
head = 0
tail = len(s) - 1
while head < tail:
while head < len(s) and s[head] not in alphabet:
head += 1
while tail > 0 and s[tail] not in alphabet:
tail -= 1
if head < tail:
s[head], s[tail] = s[tail], s[head]
head += 1
tail -= 1
return ''.join(s)
918. 环形子数组的最大和
- 题目难度
Medium
给定一个由整数数组 A 表示的环形数组 C，求 **C** 的非空子数组的最大可能和。
在此处，环形数组意味着数组的末端将会与开头相连呈环状。（形式上，当0 <= i < A.length 时 C[i] = A[i]，而当 i >= 0 时 C[i+A.length] = C[i]）
此外，子数组最多只能包含固定缓冲区 A 中的每个元素一次。（形式上，对于子数组 C[i], C[i+1], ..., C[j]，不存在 i <= k1, k2 <= j 其中 k1 % A.length = k2 % A.length）
示例 1：
输入：[1,-2,3,-2]
输出：3
解释：从子数组 [3] 得到最大和 3
示例 2：
输入：[5,-3,5]
输出：10
解释：从子数组 [5,5] 得到最大和 5 + 5 = 10
示例 3：
输入：[3,-1,2,-1]
输出：4
解释：从子数组 [2,-1,3] 得到最大和 2 + (-1) + 3 = 4
示例 4：
输入：[3,-2,2,-3]
输出：3
解释：从子数组 [3] 和 [3,-2,2] 都可以得到最大和 3
示例 5：
输入：[-2,-3,-1]
输出：-1
解释：从子数组 [-1] 得到最大和 -1
提示：
-30000 <= A[i] <= 300001 <= A.length <= 30000
思路：
两个思路：一种是将数组复制一份，拼接在原数组后边，用求连续子数组最大和的方法求解，求解过程中需要用一个队列来控制子数组长度不超过原数组的长度；另一种方法更为巧妙，将结果分为两种可能的情况，一种是不跨边界的情况直接求解，一种是跨边界则将问题转化为求解不跨边界的子数组和最小，再用原数组求和减去这个最小值则为最大值，此种方法需要考虑数组中元素全为负数的情况。
时间复杂度
空间复杂度
代码：
解法1
class Solution:
def maxSubarraySumCircular(self, A: List[int]) -> int:
l = len(A)
A = A + A
ans = A[0]
s = [0] * (2 * l)
q = [0]
for i in range(1, 2 * l):
s[i] = s[i - 1] + A[i - 1]
while q and q[0] < i - l:
q.pop(0)
ans = max(ans, s[i] - s[q[0]])
while q and s[q[-1]] > s[i]:
q.pop()
q.append(i)
return ans
解法2
class Solution:
def maxSubarraySumCircular(self, A: List[int]) -> int:
result = 0
curr_max = 0
result_max = 0
# 分两种情况
# 一种为没有跨越边界的情况，一种为跨越边界的情况 没有跨越边界的情况直接求子数组的最大和即可
for num in A:
curr_max += num
if curr_max <= 0:
curr_max = 0
if curr_max > result_max:
result_max = curr_max
# 考虑全部为负数的情况
if result_max == 0:
result = max(A)
return result
# 跨越边界的情况可以对数组求和再减去无环的子数组的最小和，即可得到跨越边界情况下的子数组最大和
curr_min = 0
result_min = 0
for num in A:
curr_min += num
if curr_min >= 0:
curr_min = 0
if curr_min < result_min:
result_min = curr_min
result = max(result_max, sum(A)-result_min)
return result
919. 完全二叉树插入器
- 题目难度
Medium
完全二叉树是每一层（除最后一层外）都是完全填充（即，结点数达到最大）的，并且所有的结点都尽可能地集中在左侧。
设计一个用完全二叉树初始化的数据结构 CBTInserter，它支持以下几种操作：
-
CBTInserter(TreeNode root)使用头结点为root的给定树初始化该数据结构； -
CBTInserter.insert(int v)将TreeNode插入到存在值为node.val = v的树中以使其保持完全二叉树的状态，并返回插入的 TreeNode 的父结点的值； -
CBTInserter.get_root()将返回树的头结点。
示例 1：
输入：inputs = ["CBTInserter","insert","get_root"], inputs = [[[1]],[2],[]]
输出：[null,1,[1,2]]
示例 2：
输入：inputs = ["CBTInserter","insert","insert","get_root"], inputs = [[[1,2,3,4,5,6]],[7],[8],[]]
输出：[null,3,4,[1,2,3,4,5,6,7,8]]
提示：
- 最初给定的树是完全二叉树，且包含
1到1000个结点。 - 每个测试用例最多调用
CBTInserter.insert操作10000次。 - 给定结点或插入结点的每个值都在
0到5000之间。
思路：
对完全二叉树每个结点进行编号，空二叉树标记为0，根结点标记为1，根结点的左儿子标记为10，根结点的右儿子标记为11，之后，每个结点如果是左儿子，就在父结点的编号后面增加一个0，如果是右儿子，就在父结点的编号后面增加一个1，以此类推。这样，完全二叉树的每个结点编号其实就代表了它是层次遍历中第几个结点的二进制编码，比如根结点是第一个结点，编号为1，二进制为1，根结点左儿子是第二个结点，编号为2，二进制为10，以此类推，每个结点的编号二进制就可以代表从根结点到这个结点的一个路径，从编号二进制的第二位开始，如果为0就走左子树，如果为1就走右子树。所以我们只需要动态维护完全二叉树的总结点个数，就可以知道插入结点在哪个位置了。
时间复杂度 初始化为 插入为 返回根结点为
空间复杂度
代码：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class CBTInserter:
def __init__(self, root: TreeNode):
self.r = root
def dfs(root):
if not root:
return 0
return dfs(root.left) + dfs(root.right) + 1
self.n = dfs(root)
def insert(self, v: int) -> int:
self.n += 1
x = self.n
path = []
while x > 0:
path.insert(0, x % 2)
x //= 2
father = self.r
for i in range(1, len(path) - 1):
if path[i] == 0:
father = father.left
else:
father = father.right
t = TreeNode(v)
if path[-1] == 0:
father.left = t
else:
father.right = t
return father.val
def get_root(self) -> TreeNode:
return self.r
# Your CBTInserter object will be instantiated and called as such:
# obj = CBTInserter(root)
# param_1 = obj.insert(v)
# param_2 = obj.get_root()
920. 播放列表的数量
- 题目难度
Hard
你的音乐播放器里有 N 首不同的歌，在旅途中，你的旅伴想要听 L 首歌（不一定不同，即，允许歌曲重复）。请你为她按如下规则创建一个播放列表：
- 每首歌至少播放一次。
- 一首歌只有在其他
K首歌播放完之后才能再次播放。
返回可以满足要求的播放列表的数量。由于答案可能非常大，请返回它模 10^9 + 7 的结果。
示例 1：
输入：N = 3, L = 3, K = 1
输出：6
解释：有 6 种可能的播放列表。[1, 2, 3]，[1, 3, 2]，[2, 1, 3]，[2, 3, 1]，[3, 1, 2]，[3, 2, 1].
示例 2：
输入：N = 2, L = 3, K = 0
输出：6
解释：有 6 种可能的播放列表。[1, 1, 2]，[1, 2, 1]，[2, 1, 1]，[2, 2, 1]，[2, 1, 2]，[1, 2, 2]
示例 3：
输入：N = 2, L = 3, K = 1
输出：2
解释：有 2 种可能的播放列表。[1, 2, 1]，[2, 1, 2]
提示：
0 <= K < N <= L <= 100
思路：
动态规划：我们用dp[i][j]代表i首不同的歌，要听j首歌组成的播放列表，有多少种情况，那么dp[N][L]即是我们所要求得的结果。显然，当i==j时，可能的方案为i的全排列。由于每一首歌都要在其他K首歌播放完后才能再次播放，所以当i==K+1时，歌曲只能按照一种排列循环，所以方案数也是i的阶乘。我们已知当前列表已经有j-1首歌的方案数，需要求有j首歌的方案数时，有两种情况，一种是播放一首从来没有播放过的歌，可以有i种选法，即dp[i-1][j-1]*i，另一种是播放一首已经播放过的歌，但是这首歌不能在最后K首歌之中，即dp[i][j-1]*(i-K)。于是可求得状态转移方程为dp[i][j] = dp[i-1][j-1]*i + dp[i][j-1]*(i-K)。
时间复杂度
空间复杂度
代码：
class Solution:
def numMusicPlaylists(self, N: int, L: int, K: int) -> int:
dp = [[0] * (L + 1) for _ in range(N + 1)]
for i in range(K + 1, N + 1):
for j in range(i, L + 1):
if i == j or i == K + 1:
dp[i][j] = math.factorial(i)
else:
dp[i][j] = dp[i - 1][j - 1] * i + dp[i][j - 1] * (i - K)
return dp[N][L] % (10 ** 9 + 7)