【LeetCode周赛】第192场周赛

一、1470. 重新排列数组：

给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。

请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。

示例：

输入：nums = [2,5,1,3,4,7], n = 3
输出：[2,3,5,4,1,7]
解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]

输入：nums = [1,2,3,4,4,3,2,1], n = 4
输出：[1,4,2,3,3,2,4,1]

输入：nums = [1,1,2,2], n = 2
输出：[1,2,1,2]

分析：

​ 相当于将数组的奇数和偶数位元素分开，依次插入。没有想到可以原地修改的办法。

代码（Python）：

class Solution:
    def shuffle(self, nums: List[int], n: int) -> List[int]:
        ans = [0] * (2 * n)
        even, odd = 0, 1
        i = 0
        j = 0
        while odd < 2 * n:
            ans[odd] = nums[n + i]
            odd += 2
            i += 1
        while even < 2 * n - 1:
            ans[even] = nums[j]
            even += 2
            j += 1
        return ans

---

二、1471. 数组中的 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 个值组成的列表。答案可以以 任意顺序 返回。

中位数 是一个有序整数列表中处于中间位置的值。形式上，如果列表的长度为 n ，那么中位数就是该有序列表（下标从 0 开始）中位于 ((n - 1) / 2) 的元素。

• 例如 arr = [6, -3, 7, 2, 11]，n = 5：数组排序后得到 arr = [-3, 2, 6, 7, 11] ，数组的中间位置为 m = ((5 - 1) / 2) = 2 ，中位数 arr[m] 的值为 6 。

• 例如 arr = [-7, 22, 17, 3]，n = 4：数组排序后得到 arr = [-7, 3, 17, 22] ，数组的中间位置为 m = ((4 - 1) / 2) = 1 ，中位数 arr[m] 的值为 3 。

示例：

输入：arr = [1,2,3,4,5], k = 2
输出：[5,1]
解释：中位数为 3，按从强到弱顺序排序后，数组变为 [5,1,4,2,3]。最强的两个元素是 [5, 1]。[1, 5] 也是正确答案。
注意，尽管 |5 - 3| == |1 - 3| ，但是 5 比 1 更强，因为 5 > 1 。

输入：arr = [1,1,3,5,5], k = 2
输出：[5,5]
解释：中位数为 3, 按从强到弱顺序排序后，数组变为 [5,5,1,1,3]。最强的两个元素是 [5, 5]。

分析：

​ 需要排序来完成，可以利用语言中自带的高级排序功能。

代码（Python）：

from typing import List
from functools import cmp_to_key


class Solution:
    def getStrongest(self, arr: List[int], k: int) -> List[int]:
        arr.sort()
        mid = arr[(len(arr) - 1) // 2]

        def strong_sort(x, y):
            if abs(x - mid) == abs(y - mid):
                return y - x
            return abs(y - mid) - abs(x - mid)

        arr.sort(key=cmp_to_key(strong_sort))
        return arr[:k]

from typing import List


class Solution:
    def getStrongest(self, arr: List[int], k: int) -> List[int]:
        arr.sort()
        mid = arr[(len(arr) - 1) // 2]

        def strong_sort(x):
            return (-abs(x - mid), -x)

        arr = sorted(arr,key=strong_sort)
        return arr[:k]

注：Python3中sort函数已经不再支持cmp（compare）参数。如果需要使用，可以引入functools包中的cmp_to_key。或者可以使用代码2中的key，写法少有不同。

---

三、1472. 设计浏览器历史记录：

你有一个只支持单个标签页的 浏览器 ，最开始你浏览的网页是 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 。

示例：

输入：
["BrowserHistory","visit","visit","visit","back","back","forward","visit","forward","back","back"]
[["leetcode.com"],["google.com"],["facebook.com"],["youtube.com"],[1],[1],[1],["linkedin.com"],[2],[2],[7]]
输出：
[null,null,null,null,"facebook.com","google.com","facebook.com",null,"linkedin.com","google.com","leetcode.com"]

解释：
BrowserHistory browserHistory = new BrowserHistory("leetcode.com");
browserHistory.visit("google.com"); // 你原本在浏览 "leetcode.com" 。访问 "google.com"
browserHistory.visit("facebook.com"); // 你原本在浏览 "google.com" 。访问 "facebook.com"
browserHistory.visit("youtube.com"); // 你原本在浏览 "facebook.com" 。访问 "youtube.com"
browserHistory.back(1); // 你原本在浏览 "youtube.com" ，后退到 "facebook.com" 并返回 "facebook.com"
browserHistory.back(1); // 你原本在浏览 "facebook.com" ，后退到 "google.com" 并返回 "google.com"
browserHistory.forward(1); // 你原本在浏览 "google.com" ，前进到 "facebook.com" 并返回 "facebook.com"
browserHistory.visit("linkedin.com"); // 你原本在浏览 "facebook.com" 。 访问 "linkedin.com"
browserHistory.forward(2); // 你原本在浏览 "linkedin.com" ，你无法前进任何步数。
browserHistory.back(2); // 你原本在浏览 "linkedin.com" ，后退两步依次先到 "facebook.com" ，然后到 "google.com" ，并返回 "google.com"
browserHistory.back(7); // 你原本在浏览 "google.com"， 你只能后退一步到 "leetcode.com" ，并返回 "leetcode.com"

分析：

​ 当时这道题没有做出来。有一个关键的地方没有理解到位。

例如示例中：当页面处在 facebook时访问了 linkedin，这时就无法向前到达原来的 youtube。

​ 所以不需要复杂的数据结构。列表就可以很好的解决这个问题。

代码（Python）：

class BrowserHistory:

    def __init__(self, homepage: str):
        self.history = [homepage]
        self.index = 0
        self.last = self.index + 1

    def visit(self, url: str) -> None:
        # 如果超出列表，就使用append扩展一下
        if self.index == len(self.history) - 1:
            self.history.append(url)
        else:
            self.history[self.index + 1] = url
        self.index += 1
        self.last = self.index + 1

    def back(self, steps: int) -> str:
        steps = min(self.index, steps)
        self.index -= steps
        return self.history[self.index]

    def forward(self, steps: int) -> str:
        # last储存列表长度，这一步是为了查看steps是否溢出
        steps = min(self.last - self.index - 1, steps)
        self.index += steps
        return self.history[self.index]

---

四、1473. 给房子涂色 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 。

示例：

输入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出：9
解释：房子涂色方案为 [1,2,2,1,1]
此方案包含 target = 3 个街区，分别是 [{1}, {2,2}, {1,1}]。
涂色的总花费为 (1 + 1 + 1 + 1 + 5) = 9。

分析：

​ 这道题是一道很明显的动态规划，但是需要一个高维的dp数组。能力有限，比赛后看着大佬的题解写的Golang版本。状态转移方程和一些关键步骤都在注释中写了一些，以后理解加深了再来补。

代码（Golang）：

func minCost(houses []int, cost [][]int, m int, n int, target int) int {
	// 三维dp数组初始化
	// dp[i][j][k]表示第i个房子涂第j个颜色，前i个房子形成了k个社区
	dp := make([][][]int, m)
	for i := 0; i < m; i++ {
		dp[i] = make([][]int, n + 1)
		for j := 0; j < n + 1; j++ {
			dp[i][j] = make([]int, target + 1)
			for k := 0; k < target + 1; k++ {
				dp[i][j][k] = math.MaxInt32
			}
		}
	}

	//// 如果房子未涂色，需要重新涂色
	if houses[0] == 0 {
		for i := 1; i < n + 1; i++ {
			// 颜色可以随意涂
			dp[0][i][1] = cost[0][i - 1]
		}
	}

	// dp状态转移
	// k的值是由当前房子颜色和前一个房子颜色作比较得到的：
	// 1.i号房子颜色和i-1号房子颜色相同，i,k的值从i-1,k得到
	// 2.i号房子颜色和i-1号房子颜色不同，i,k的值从i-1,k-1得到
	for i := 1; i < m; i++ {
		if houses[i] == 0 {
			for j1 := 1; j1 < n + 1; j1++ {
				for k := 1; k < target + 1; k++ {
					for j2 := 1; j2 < n + 1; j2++ {
						if j1 == j2 {
							dp[i][j1][k] = min(dp[i][j1][k], dp[i - 1][j2][k] + cost[i][j1 - 1])
						} else {
							dp[i][j1][k] = min(dp[i][j1][k], dp[i - 1][j2][k - 1] + cost[i][j1 -1])
						}
					}
				}
			}
		} else {  // 不需要涂色的也需要更新dp数组
			for k := 1; k < target + 1; k++ {
				for j2 := 1; j2 < n + 1; j2++ {
					j1 := houses[i]
					if j1 == j2 {
						dp[i][j1][k] = min(dp[i][j1][k], dp[i - 1][j2][k])
					} else {
						dp[i][j1][k] = min(dp[i][j1][k], dp[i - 1][j2][k - 1])
					}
				}
			}
		}
	}
	ans := math.MaxInt32
	// 寻找满足社区数且涂色费用最低的涂色方案
	for i := 1; i < n+ 1; i++ {
		ans = min(ans, dp[m - 1][i][target])
	}
	if ans == math.MaxInt32 {
		ans = -1
	}
	return ans
}

func min(nums ...int) int {
	min := nums[0]
	for i := 1; i < len(nums); i++ {
		if nums[i] < min {
			min = nums[i]
		}
	}
	return min
}

---