链接：LeetCode
[Leetcode]5428. 重新排列数组
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。
其实是洗牌算法问题，但通过新建一个数组很容易解决。
class Solution:
def shuffle(self, nums: List[int], n: int) -> List[int]:
res = []
for i in range(n):
res.append(nums[i])
res.append(nums[i+n])
return res
[Leetcode]5429. 数组中的 k 个最强值
给你一个整数数组 arr 和一个整数 k 。
设 m 为数组的中位数，只要满足下述两个前提之一，就可以判定 arr[i] 的值比 arr[j] 的值更强：
|arr[i] - m| > |arr[j] - m|
|arr[i] - m| == |arr[j] - m|，且 arr[i] > arr[j]
请返回由数组中最强的 k 个值组成的列表。答案可以以 任意顺序 返回。
排序后，双指针遍历即可。
class Solution:
def getStrongest(self, arr: List[int], k: int) -> List[int]:
arr.sort()
n = len(arr)
m = arr[(n-1)//2]
start,end = 0,n-1
res = []
for i in range(k):
if abs(arr[end]-m) >= abs(arr[start]-m):
res.append(arr[end])
end -= 1
else:
res.append(arr[start])
start += 1
return res
[Leetcode]5430. 设计浏览器历史记录
你有一个只支持单个标签页的 浏览器 ，最开始你浏览的网页是 homepage ，你可以访问其他的网站 url ，也可以在浏览历史中后退 steps 步或前进 steps 步。
请你实现 BrowserHistory 类：
- BrowserHistory(string homepage) ，用 homepage 初始化浏览器类。
- void visit(string url) 从当前页跳转访问 url 对应的页面 。执行此操作会把浏览历史前进的记录全部删除。
- string back(int steps) 在浏览历史中后退 steps 步。如果你只能在浏览历史中后退至多 x 步且 steps > x ，那么你只后退 x 步。请返回后退 至多 steps 步以后的 url 。
- string forward(int steps) 在浏览历史中前进 steps 步。如果你只能在浏览历史中前进至多 x 步且 steps > x ，那么你只前进 x 步。请返回前进 至多 steps步以后的 url 。
新建一个栈，引入当前位置即可。
class BrowserHistory:
def __init__(self, homepage: str):
self.visited = [homepage]
self.flag = 0
self.end = 0
def visit(self, url: str) -> None:
for i in range(len(self.visited)-self.flag-1):
self.visited.pop()
self.visited.append(url)
self.flag += 1
def back(self, steps: int) -> str:
steps = min(steps,self.flag)
self.flag -= steps
return self.visited[self.flag]
def forward(self, steps: int) -> str:
steps = min(steps,len(self.visited)-self.flag-1)
self.flag += steps
return self.visited[self.flag]
[Leetcode]5431. 给房子涂色 III
在一个小城市里，有 m 个房子排成一排，你需要给每个房子涂上 n 种颜色之一（颜色编号为 1 到 n ）。有的房子去年夏天已经涂过颜色了，所以这些房子不需要被重新涂色。
我们将连续相同颜色尽可能多的房子称为一个街区。（比方说 houses = ([1,2,2,3,3,2,1,1]) ，它包含 5 个街区 ([{1}, {2,2}, {3,3}, {2}, {1,1}]) 。）
给你一个数组 houses ，一个 m * n 的矩阵 cost 和一个整数 target ，其中：
- (houses[i])：是第 i 个房子的颜色，0 表示这个房子还没有被涂色。
- (cost[i][j])：是将第 i 个房子涂成颜色 j+1 的花费。
请你返回房子涂色方案的最小总花费，使得每个房子都被涂色后，恰好组成 target 个街区。如果没有可用的涂色方案，请返回 -1 。
与普通的二维动态规划相比，这里的主要难点是引入了多种颜色，因此我们需要将二维扩充为三维。定义(dp[i][j][k])为第i个房子颜色为j,且到目前为止，一共有k个街区的最小花费.
在扩展状态的时候，如果当前颜色和上一个颜色相同，则街区数不变，否则街区数+1.
另外特别需要注意对数组进行初始化，最后输出的时候，也需要比较一下不同颜色下k个街区的最小花费.
class Solution:
def minCost(self, houses: List[int], cost: List[List[int]], m: int, n: int, target: int) -> int:
dp = [[[float('inf') for k in range(target+1)] for j in range(n)] for i in range(m+1)]
for j in range(n):
dp[0][j][0] = 0
for i in range(1,m+1):
for j in range(n):
for k in range(1,min(i+1,target+1)):
if houses[i-1]!=0:
dp[i][houses[i-1]-1][k] = dp[i-1][houses[i-1]-1][k]
for other in range(n):
if other == houses[i-1]-1:continue
dp[i][houses[i-1]-1][k] = min(dp[i][houses[i-1]-1][k],dp[i-1][other][k-1])
else:
dp[i][j][k] = dp[i-1][j][k] + cost[i-1][j]
for other in range(n):
if other == j:continue
dp[i][j][k] = min(dp[i][j][k],dp[i-1][other][k-1]+cost[i-1][j])
res = min([x[-1] for x in dp[-1]])
return res if res!=float('inf') else -1