[Leetcode Weekly Contest]192

链接：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