LeetCode第192场周赛（Weekly Contest 192）解题报告
这周日校庆，庆祝工大 100 岁。去参加校庆活动了，补题发现不难，特别最后一题，就是常规的 DP 问题。
第一题：模拟
第二题：排序
第三题：模拟。
第四题：动态规划 DP。
详细题解如下。
1.重新排列数组
AC代码（C++）
2. 数组中的 k 个最强值
AC代码（C++）
3.设计浏览器历史记录
AC代码（C++）
4.给房子涂色 III
AC代码（C++）
LeetCode第 192 场周赛地址：
https://leetcode-cn.com/problems/shuffle-the-array/
1.重新排列数组
题目链接
https://leetcode-cn.com/problems/shuffle-the-array/
题意
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。
示例 1：
输入：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]示例 2：
输入：nums = [1,2,3,4,4,3,2,1], n = 4 输出：[1,4,2,3,3,2,4,1]示例 3：
输入：nums = [1,1,2,2], n = 2 输出：[1,2,1,2]提示：
1 <= n <= 500nums.length == 2n1 <= nums[i] <= 10^3
解题思路
根据题意，送分题。
相当于分成了 两个 n 长度的数组，遍历前 n 个数的时候，放其中一个数的同时，放该位置 + n 的那个数，就可以重排列得到结果。
AC代码（C++）
class Solution {
public:
vector shuffle(vector& nums, int n) {
vector ans;
for(int i = 0;i < n; ++i)
{
ans.push_back(nums[i]);
ans.push_back(nums[i + n]);
}
return ans;
}
}; 2. 数组中的 k 个最强值
题目链接
https://leetcode-cn.com/problems/the-k-strongest-values-in-an-array/
题意
给你一个整数数组 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 。示例 1：
输入：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 。示例 2：
输入：arr = [1,1,3,5,5], k = 2 输出：[5,5] 解释：中位数为 3, 按从强到弱顺序排序后，数组变为 [5,5,1,1,3]。最强的两个元素是 [5, 5]。示例 3：
输入：arr = [6,7,11,7,6,8], k = 5 输出：[11,8,6,6,7] 解释：中位数为 7, 按从强到弱顺序排序后，数组变为 [11,8,6,6,7,7]。 [11,8,6,6,7] 的任何排列都是正确答案。提示：
1 <= arr.length <= 10^5-10^5 <= arr[i] <= 10^51 <= k <= arr.length
解题思路
根据题意，其实就是我们对原数组排序，取出前 k 个即可。
我们排序的依据就是
- |arr[i] - m| > |arr[j] - m|
- |arr[i] - m| == |arr[j] - m|，且 arr[i] > arr[j]
C++ 就是调用 sort ，然后 重写 cmp 即可。
排序依据中，我们先要求出 m（中位数），因为一开始的数组不一定是有序的，因此我们先要一开始对 数组排序，从而求出 中位数。
所以，这道题，其实就是，写两次排序，一次排序默认排序即可，另一次排序就是我们重写 cmp 即可。
AC代码（C++）
int m;
bool cmp(int a, int b)
{
if(abs(a - m) != abs(b - m)) return abs(a - m) > abs(b - m);
return a > b;
}
class Solution {
public:
vector getStrongest(vector& arr, int k) {
sort(arr.begin(), arr.end());
int n = arr.size();
m = arr[(n - 1) / 2];
sort(arr.begin(), arr.end(), cmp);
vector ans;
for(int i = 0;i < k; ++i)
{
ans.push_back(arr[i]);
}
return ans;
}
}; 3.设计浏览器历史记录
题目链接
https://leetcode-cn.com/problems/design-browser-history/
题意
你有一个只支持单个标签页的 浏览器 ，最开始你浏览的网页是 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 。
示例 1：
输入： ["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"提示：
- 1 <= homepage.length <= 20
- 1 <= url.length <= 20
- 1 <= steps <= 100
- homepage 和 url 都只包含 '.' 或者小写英文字母。
- 最多调用 5000 次 visit， back 和 forward 函数。
解题分析
其实也就是一个简单的模拟，我们先要理解做什么
- 1、visit，就是我们不断的点击到下一个（保存新的 网页），这个时候要注意，如果是，往back走（本来应该记录有后面的网页），这些后面的网页被新的覆盖掉
- 2、back 就是回退几个，得到对应的网页
- 3、forward 就是 往前走 几个，得到对应的网页
那么我们相当于要保存网页，同时又要回退前进，即快速得到，那么 就希望可以快速访问，那么想到的就是，利用 数组来保存。
那么此时，我们对于数组，应该要有几个参数
len（其实也可以不用，因为是用 vector 可以得到），此时这个数组的长度，这样子，当长度不够的时候，还要往里面加数据，就需要用 push_back
curPos，记录当前的所在网址的下标
maxPos，记录的是，我们需要知道，这次有效的，网页最大下标。（注意，这个和 len 不同，len 是我们对于数组的整个长度，比如长度是 5，当我们回退 并且 重新 visit 的时候，是要更新 visist 后面的数据的，所以 数组的最大长度，不是我们 的有效网页个数，所以需要用 maxPos 这个变量来记录）
然后，剩下就是根据题目来 模拟即可。
AC代码（C++）
class BrowserHistory {
public:
vector allUrl;
int curPos;
int maxPos;
BrowserHistory(string homepage) {
allUrl.clear();
allUrl.push_back(homepage);
curPos = 0;
maxPos = 0;
}
void visit(string url) {
if(curPos == maxPos) // 如果 cur == max，说明此时所在的是有效的最后一个，那么此时 visit 就是加在后面
{
// 但是加入的时候，我们因为是用 vector，要看是利用 push_back，还是直接更新
if(allUrl.size() - 1 == maxPos)
{
allUrl.push_back(url);
curPos++;
maxPos++;
}
else
{
curPos++;
maxPos++;
allUrl[curPos] = url;
}
}
else // 如果 cur 和 max 不等，说明是之前回退过，那么 直接加在 cur 后一个位置，同时因为重新 visit 了，那么就覆盖，所以 max 也要变动。
{
allUrl[curPos + 1] = url;
curPos++;
maxPos = curPos;
}
}
string back(int steps) {
if(steps > curPos) steps = curPos; // 回退，curPos 可以回退的最大长度，如果不够，就只能这个最大回退
curPos -= steps; // 更新 curPos
return allUrl[curPos]; // 然后根据数组下标就可以
}
string forward(int steps) { // 同理，我们此时 curPos 到 maxPos 是可以前进的位置，所以前进步数是有限的
if(steps > maxPos - curPos) steps = maxPos - curPos;
curPos += steps;
return allUrl[curPos];
}
};
/**
* Your BrowserHistory object will be instantiated and called as such:
* BrowserHistory* obj = new BrowserHistory(homepage);
* obj->visit(url);
* string param_2 = obj->back(steps);
* string param_3 = obj->forward(steps);
*/ 4.给房子涂色 III
题目链接
https://leetcode-cn.com/problems/paint-house-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 。
示例 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。示例 2：
输入：houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3 输出：11 解释：有的房子已经被涂色了，在此基础上涂色方案为 [2,2,1,2,2] 此方案包含 target = 3 个街区，分别是 [{2,2}, {1}, {2,2}]。 给第一个和最后一个房子涂色的花费为 (10 + 1) = 11。提示：
m == houses.length == cost.lengthn == cost[i].length1 <= m <= 1001 <= n <= 201 <= target <= m0 <= houses[i] <= n1 <= cost[i][j] <= 10^4
解题分析
题目看的很复杂，但是看到是要求出 最小总花费，那么想到就是 动态规划的问题。
题目很长，但是解释很详细，也说明了 状态情况
我们设 dp[ i ][ j ][ t ]，前 i 个房子，并且第 i 个房子的颜色是 j，此时组成了 t 个街区的 最小总花费。
那么状态转移
我们就遍历 i，那么对于 第 i 个房子，有两种情况（此时我们枚举 i - 1 的颜色是 k，对应街区数是 t ）
1、本来就是有颜色的（此时转移不需要 cost ）。那么此时直接根据 dp[ i - 1][ ~ ][ ~ ] 枚举 第 i - 1 的情况，然后 结合 此时 i 的颜色 来转移。此时又有两种情况，第一种是，i - 1 和 i 是同颜色，那么，就可以直接 dp[ i ][ j ][ t] =min( dp[ i - 1][ j ][ t ])，同颜色，街区数不变。第二种，不同颜色，街区数 + 1，即 dp[ i ][ j ][ t + 1 ] =min( dp[ i - 1][ k ][ t ])
2、本来没颜色，那么枚举 i 可以涂的颜色（此时就有 cost）， j。同样的，也是两种情况 。第一种是，i - 1 和 i 是同颜色，那么，就可以直接 dp[ i ][ j ][ t] =min( dp[ i - 1][ j ][ t ] + cost [i - 1] [ j - 1] )，同颜色，街区数不变。第二种，不同颜色，街区数 + 1，即 dp[ i ][ j ][ t + 1 ] =min( dp[ i - 1][ k ][ t ] + cost [i - 1] [ j - 1] )
初始化
因为是求，最小花费，所以我们设所有 dp 是最大值
并且，对于第一个房子，如果本身有颜色，那么对应的 dp[ 1 ][ 颜色 ][ 1 ] = 0，因为本来就有颜色，就是无花费。如果本身没眼色，那么是可以涂成任何颜色的 dp[ 1 ][ all j ][ 1 ] = cost[ 0 ][ j - 1]，花费对应颜色的开销。
最后答案
我们无法知道 最后一个 房子对应的哪种颜色时，最便宜，所以就遍历
找出 dp[ n][ all j][ target ] 中的 最小值就是答案。
假如这个答案还是 == INF，那么相当于没有可用的 涂色方案，就返回 -1
时间复杂度，我们遍历 房子，然后遍历 i 的颜色，遍历 i - 1 的颜色，遍历 街区数。总共是 O(m * n * n * m)，根据数据范围，不会超时。
AC代码（C++）
const int INF = 1e7 + 50;
class Solution {
public:
int minCost(vector& houses, vector>& cost, int m, int n, int target) {
vector > > dp(m + 1, vector > (n + 1, vector (m + 1, INF)));
if(houses[0] != 0) dp[1][houses[0]][1] = 0;
else
{
for(int j = 1;j <= n; ++j) dp[1][j][1] = cost[0][j - 1];
}
for(int i = 2;i <= m; ++i)
{
if(houses[i - 1] != 0)
{
int j = houses[i - 1];
for(int k = 1;k <= n; ++k)
{
for(int t = 1;t <= target; ++t)
{
if(j == k) // t -> t
{
dp[i][j][t] = min(dp[i][j][t], dp[i - 1][k][t]);
}
else // t -> t + 1
{
if(t + 1 <= target) dp[i][j][t + 1] = min(dp[i][j][t + 1], dp[i - 1][k][t]);
}
}
}
}
else
{
for(int j = 1;j <= n; ++j)
{
for(int k = 1;k <= n; ++k)
{
for(int t = 1;t <= target; ++t)
{
if(j == k) // t -> t
{
dp[i][j][t] = min(dp[i][j][t], dp[i - 1][k][t] + cost[i - 1][j - 1]);
}
else // t -> t + 1
{
if(t + 1 <= target) dp[i][j][t + 1] = min(dp[i][j][t + 1], dp[i - 1][k][t] + cost[i - 1][j - 1]);
}
}
}
}
}
}
int ans = INF;
for(int j = 1;j <= n; ++j)
{
ans = min(ans, dp[m][j][target]);
}
if(ans == INF) return -1;
return ans;
}
};