LeetCode 第192场周赛 题解
文章目录
- a.重新排列数组
- a.题目
- a.分析
- a.参考代码
- b.数组中的 k 个最强值
- b.题目
- b.分析
- b.参考代码
- c.设计浏览器历史记录
- c.题目
- c.分析
- c.参考代码
- d.给房子涂色 III
- d.题目
- d.分析
- d.参考代码
a.重新排列数组
a.题目
给你一个数组 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 <= 500
- nums.length == 2n
- 1 <= nums[i] <= 10^3
a.分析
很明显我们可以直接通过公式得知xi和yi的位置在哪的
xi=i yi=i+n
所以直接按i的顺序把xi yi依次push进去就行了
总的时间复杂度为O（n）
a.参考代码
class Solution {
public:
vector<int> shuffle(vector<int>& nums, int n) {
vector<int> ans;
for(int i=0;i<n;i++)
{
ans.push_back(nums[i]); //xi
ans.push_back(nums[i+n]); //yi
}
return ans;
}
};
b.数组中的 k 个最强值
b.题目
给你一个整数数组 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] 的任何排列都是正确答案。
示例 4
输入：arr = [6,-3,7,2,11], k = 3
输出：[-3,11,2]
示例 5
输入：arr = [-7,22,17,3], k = 2
输出：[22,17]
提示
- 1 <= arr.length <= 10^5
- -10^5 <= arr[i] <= 10^5
- 1 <= k <= arr.length
b.分析
先把中位数mid给找出来
这里注意要根据题目的公式sorted_arr[(n-1)/2]是中位数 偶数情况不是小数来的
那么这里可以直接对升序排序得到sorted_arr来得到中位数
得到中位数之后 其实对于arr来说 强与弱其实是个大小关系
你只需要根据这个大小关系来进行对arr排序就行
最后取前k个即可
总的时间复杂度排序用时O（nlogn）
其实可以直接在原数组进行两次排序都没有关系的
比赛时候找中位数我另外开了个数组
b.参考代码
class Solution {
public:
vector<int> getStrongest(vector<int>& arr, int k) {
vector<int> v=arr; //找中位数的数组
sort(v.begin(),v.end());
int n=arr.size();
int mid=v[(n-1)/2];
sort(arr.begin(),arr.end(),[mid](int a,int b)->bool{
if(abs(a-mid)==abs(b-mid)) return a>b;
return abs(a-mid)>abs(b-mid);
}); //lambda表达式 根据题目的大小关系排序
vector<int> ans;
for(int i=0;i<k;i++)ans.push_back(arr[i]); //前k个
return ans;
}
};
c.设计浏览器历史记录
c.题目
你有一个只有一个标签页的 浏览器 ，一开始你浏览的网页是 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”
提示
- 1 <= homepage.length <= 20
- 1 <= url.length <= 20
- 1 <= steps <= 100
- homepage 和 url 都只包含 ‘.’ 或者小写英文字母。
- 最多调用 5000 次 visit， back 和 forward 函数。
c.分析
后退这个操作很容易就能想到栈的操作
而前进就很容易想到反向栈的操作
所以结合起来就是用的对顶栈来模拟
栈1表示当前和历史 栈2表示可以前进的
- 新进一个网页 直接压入栈1 并且清空栈2
- 后退网页 不断把栈1的网页弹出到栈2 （因为可以前进回去）直到steps完成或栈1只剩最后一个
- 前进网页 不断把栈2的网页弹出到栈1 直到steps完成或者栈2空了
- 返回的网页永远都是栈1的栈顶
时间复杂度大概是前进后退每次都要进行O（steps）次移动元素
访问的话为O（1）
c.参考代码
class BrowserHistory {
public:
stack<string> stk1,stk2;
BrowserHistory(string homepage) {
stk1.push(homepage); //初始
}
void visit(string url) {
stk1.push(url); //进栈
while(stk2.size())stk2.pop(); //清空前进栈 栈没有clear()
}
string back(int steps) {
while(stk1.size()>1&&steps--) //后退至多steps
{
stk2.push(stk1.top());
stk1.pop();
}
if(stk1.size())return stk1.top();
else return ""; //应该不会有这种调用情况
}
string forward(int steps) {
while(stk2.size()&&steps--) //前进至多steps
{
stk1.push(stk2.top());
stk2.pop();
}
if(stk1.size())return stk1.top();
else return ""; //应该不会有这种调用情况
}
};
d.给房子涂色 III
d.题目
在一个小城市里，有 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。
示例 3
输入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5
输出：5
示例 4
输入：houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3
输出：-1
解释：房子已经被涂色并组成了 4 个街区，分别是 [{3},{1},{2},{3}] ，无法形成 target = 3 个街区。
提示
- m == houses.length == cost.length
- n == cost[i].length
- 1 <= m <= 100
- 1 <= n <= 20
- 1 <= target <= m
- 0 <= houses[i] <= n
- 1 <= cost[i][j] <= 10^4
d.分析
这种一看就是dp的最小花费问题
而且是线性dp 因为刷墙可以从左到右依次遍历观察（街区是否增加只和它的上一个有关）
首先我们来规定状态：
dp[i][j][k]表示为
- 现在遍历到第i个房子（前面1~i-1）都遍历过了
- 你打算把这个刷成j这种颜色
- 现在你想它有k个街区
的最小花费
也就是说这些状态都是子问题的答案
先上推导出来的状态转移方程：
dp[i][j][k]=min(dp[i-1][0~n][j==jj?k:k-1])+cost[i][j] 其中jj为0~n
是什么意思呢？
首先我们要算出某个状态ijk时候最小花费
只需要看下前面的那个房子涂的所有颜色哪个最小即可
所以dp[i-1][0~n][]应该是很容易理解的
重点在k这里 因为我们是固定街区的值的 而街区的值和上一个有关 具体表现为如何和上一个颜色一样就街区数一样 不一样就当前街区数会+1
因此就有了dp[][][j==jj?k:k-1]
如果当前房子已经涂过颜色 那么自然是不需要选择j是多少 j就是houses[i] 而且注意不需要花费
那么这个房子的作用就是起到了过滤其他状态 会把其他状态设置为非法（代码具体表现为答案值为无穷大）
初始化小细节：
初始化dp的时候应该只把dp[0][0~j][0]设置为0
这里i从1开始 方便转移 也就是i==0是特殊无意义状态
因为只有第一个房子允许从k==0转移过来
总的时间复杂度是O（mn^3）
d.参考代码
class Solution {
public:
int dp[105][25][105]; //dp状态
int minCost(vector<int>& houses, vector<vector<int>>& cost, int m, int n, int target) {
memset(dp,0x3f,sizeof(dp)); //全部初始化为非法
for(int i=0;i<n;i++)dp[0][i][0]=0; //只允许i==1从k==0转移过来
for(int i=1;i<=m;i++)
for(int j=0;j<n;j++)
for(int k=1;k<=target;k++)
{
if(houses[i-1]){ //如果已经涂色了
if(j==houses[i-1]-1) //只有j和这个颜色相同才是合法的 否则不填充这个状态
for(int jj=0;jj<n;jj++)
dp[i][j][k]=min(dp[i][j][k],dp[i-1][jj][jj==j?k:k-1]);
continue;
}
else{
for(int jj=0;jj<n;jj++) //遍历前一个的所有颜色情况
dp[i][j][k]=min(dp[i][j][k],dp[i-1][jj][jj==j?k:k-1]+cost[i-1][j]);
}
}
int ans=0x3f3f3f3f;
for(int j=0;j<n;j++)ans=min(ans,dp[m][j][target]); //找最小的答案 我们不知道最后填哪个颜色更优
return ans==0x3f3f3f3f?-1:ans;
}
};