LeetCode 第 22 场双周赛（220/2041，前10.8%）

文章目录

1. 比赛结果
2. 题目
- LeetCode 5348. 两个数组间的距离值 easy
- LeetCode 5349. 安排电影院座位 medium
- LeetCode 5350. 将整数按权重排序 medium
- LeetCode 5351. 3n 块披萨 hard

1. 比赛结果

做出来了前3题，第4题有点难，感觉是动态规划。

全国排名：220 / 2041，10.8%；全球排名：729 / 5630，12.9%

2. 题目

LeetCode 5348. 两个数组间的距离值 easy

题目链接

给你两个整数数组 arr1 ， arr2 和一个整数 d ，请你返回两个数组之间的 距离值 。

「距离值」 定义为符合此描述的元素数目：对于元素 arr1[i] ，不存在任何元素 arr2[j] 满足 |arr1[i]-arr2[j]| <= d 。

示例 1：
输入：arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
输出：2
解释：
对于 arr1[0]=4 我们有：
|4-10|=6 > d=2
|4-9|=5 > d=2
|4-1|=3 > d=2
|4-8|=4 > d=2
对于 arr1[1]=5 我们有：
|5-10|=5 > d=2
|5-9|=4 > d=2
|5-1|=4 > d=2
|5-8|=3 > d=2
对于 arr1[2]=8 我们有：
|8-10|=2 <= d=2
|8-9|=1 <= d=2
|8-1|=7 > d=2
|8-8|=0 <= d=2示例 2：
输入：arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
输出：2示例 3：
输入：arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
输出：1提示：
1 <= arr1.length, arr2.length <= 500
-10^3 <= arr1[i], arr2[j] <= 10^3
0 <= d <= 100

解答：

暴力查找即可

class Solution {public:int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {int i, j, count = 0;bool flag;for(i = 0; i < arr1.size(); i++) {flag = true;for(j = 0 ; j < arr2.size(); j++){if(abs(arr1[i]-arr2[j]) <= d){flag = false;break;}}if(flag)count++;}return count;}
};

执行用时：8 ms
内存消耗：8.3 MB

LeetCode 5349. 安排电影院座位 medium

题目链接

如上图所示，电影院的观影厅中有 n 行座位，行编号从 1 到 n ，且每一行内总共有 10 个座位，列编号从 1 到 10 。

给你数组 reservedSeats ，包含所有已经被预约了的座位。比如说，researvedSeats[i]=[3,8] ，它表示第 3 行第 8 个座位被预约了。

请你返回最多能安排多少个 4 人家庭 。4 人家庭要占据同一行内连续的 4 个座位。隔着过道的座位（比方说 [3,3] 和 [3,4]）不是连续的座位，但是如果你可以将 4 人家庭拆成过道两边各坐 2 人，这样子是允许的。

示例 1：

输入：n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]
输出：4
解释：上图所示是最优的安排方案，总共可以安排 4 个家庭。
蓝色的叉表示被预约的座位，橙色的连续座位表示一个 4 人家庭。示例 2：
输入：n = 2, reservedSeats = [[2,1],[1,8],[2,6]]
输出：2示例 3：
输入：n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]
输出：4提示：
1 <= n <= 10^9
1 <= reservedSeats.length <= min(10*n, 10^4)
reservedSeats[i].length == 2
1 <= reservedSeats[i][0] <= n
1 <= reservedSeats[i][1] <= 10
所有 reservedSeats[i] 都是互不相同的。

解题：

超时做法，先按排，排序，然后按排，统计一排的情况，做出判断，判断n排
缺点，n 非常大，会超时

class Solution { //超时代码
public:int maxNumberOfFamilies(int n, vector<vector<int>>& Seats) {int count = 0, line = 1, i = 0;sort(Seats.begin(), Seats.end(),[&](auto a, auto b){if(a[0] != b[0])return a[0] < b[0];return a[1] < b[1];});for(line = 1; line <= n; ++line){   bitset<11> b;while(i < Seats.size() && Seats[i][0] == line){b.set(Seats[i][1], 1);i++;}if(b.count() == 0 || (!b[2]&&!b[3]&&!b[4]&&!b[5]&&!b[6]&&!b[7]&&!b[8]&&!b[9]))count += 2;else if((!b[2]&&!b[3]&&!b[4]&&!b[5]) && (b[6]||b[7]||b[8]||b[9]))count += 1;else if((!b[6]&&!b[7]&&!b[8]&&!b[9]) && (b[2]||b[3]||b[4]||b[5]))count += 1;else if((!b[4]&&!b[5]&&!b[6]&&!b[7])&& (b[2]||b[3]) && (b[8]||b[9]))count += 1;}return count;}
};

采用 map + bitset 存储座位情况
遍历所有的 bitset ，分类讨论即可
跳过没有座位坐人的排，直接 +2

class Solution {public:int maxNumberOfFamilies(int n, vector<vector<int>>& Seats) {int count = 0, line = 1, i = 0;map<int,bitset<11>> m;//牌号，座位分布for(auto& st : Seats){m[st[0]].set(st[1]);}bitset<11> b;for(auto& mi : m)//遍历座位分布，m的size表示有人坐的排{   b = mi.second;if(!b[2]&&!b[3]&&!b[4]&&!b[5]&&!b[6]&&!b[7]&&!b[8]&&!b[9])count += 2;else if((!b[2]&&!b[3]&&!b[4]&&!b[5]) && (b[6]||b[7]||b[8]||b[9]))count += 1;else if((!b[6]&&!b[7]&&!b[8]&&!b[9]) && (b[2]||b[3]||b[4]||b[5]))count += 1;else if((!b[4]&&!b[5]&&!b[6]&&!b[7]) && (b[2]||b[3]) && (b[8]||b[9]))count += 1;}return count+2*(n-m.size());//没有人坐的，可以有2个家庭}
};

执行用时：180 ms
内存消耗：42.3 MB

LeetCode 5350. 将整数按权重排序 medium

题目链接

我们将整数 x 的 权重 定义为按照下述规则将 x 变成 1 所需要的步数：

如果 x 是偶数，那么 x = x / 2
如果 x 是奇数，那么 x = 3 * x + 1
比方说，x=3 的权重为 7 。因为 3 需要 7 步变成 1 （3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1）。

给你三个整数 lo， hi 和 k 。你的任务是将区间 [lo, hi] 之间的整数按照它们的权重升序排序，如果大于等于 2 个整数有相同的权重，那么按照数字自身的数值升序排序。

请你返回区间 [lo, hi] 之间的整数按权重排序后的第 k 个数。

注意，题目保证对于任意整数 x （lo <= x <= hi），它变成 1 所需要的步数是一个 32 位有符号整数。

示例 1：
输入：lo = 12, hi = 15, k = 2
输出：13
解释：12 的权重为 9（12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1）
13 的权重为 9
14 的权重为 17
15 的权重为 17
区间内的数按权重排序以后的结果为 [12,13,14,15] 。对于 k = 2 ，答案是第二个整数也就是 13 。
注意，12 和 13 有相同的权重，所以我们按照它们本身升序排序。14 和 15 同理。示例 2：
输入：lo = 1, hi = 1, k = 1
输出：1示例 3：
输入：lo = 7, hi = 11, k = 4
输出：7
解释：区间内整数 [7, 8, 9, 10, 11] 对应的权重为 [16, 3, 19, 6, 14] 。
按权重排序后得到的结果为 [8, 10, 11, 7, 9] 。
排序后数组中第 4 个数字为 7 。示例 4：
输入：lo = 10, hi = 20, k = 5
输出：13示例 5：
输入：lo = 1, hi = 1000, k = 777
输出：570提示：
1 <= lo <= hi <= 1000
1 <= k <= hi - lo + 1

解题：

lambda 表达式自定义排序即可

class Solution {public:int getKth(int lo, int hi, int k) {vector<int> v(hi-lo+1);int j = 0;for(int i = lo; i <= hi; i++)v[j++] = i;sort(v.begin(), v.end(),[&](int a, int b) {int wa = calw(a), wb = calw(b);if(wa == wb)return a < b;return wa < wb;});return v[k-1];}int calw(int x){int count = 0;while(x != 1){if(x%2)x = 3*x+1;elsex = x/2;count++;}return count;}
};

执行用时：236 ms
内存消耗：8.8 MB

LeetCode 5351. 3n 块披萨 hard

题目链接

给你一个披萨，它由 3n 块不同大小的部分组成，现在你和你的朋友们需要按照如下规则来分披萨：

你挑选任意一块披萨。
Alice 将会挑选你所选择的披萨逆时针方向的下一块披萨。
Bob 将会挑选你所选择的披萨顺时针方向的下一块披萨。
重复上述过程直到没有披萨剩下。

每一块披萨的大小按顺时针方向由循环数组 slices 表示。

请你返回你可以获得的披萨大小总和的最大值。

示例 1：

输入：slices = [1,2,3,4,5,6]
输出：10
解释：选择大小为 4 的披萨，Alice 和 Bob 分别挑选大小为 3 和 5 的披萨。
然后你选择大小为 6 的披萨，Alice 和 Bob 分别挑选大小为 2 和 1 的披萨。
你获得的披萨总大小为 4 + 6 = 10 。

示例 2：

输入：slices = [8,9,8,6,1,1]
输出：16
解释：两轮都选大小为 8 的披萨。如果你选择大小为 9 的披萨，你的朋友们就会选择大小为 8 的披萨，这种情况下你的总和不是最大的。示例 3：
输入：slices = [4,1,2,5,8,3,1,9,7]
输出：21示例 4：
输入：slices = [3,1,2]
输出：3提示：
1 <= slices.length <= 500
slices.length % 3 == 0
1 <= slices[i] <= 1000

解题：

参考此处

class Solution {public:int maxSizeSlices(vector<int>& slices) {int i, j, n = slices.size()/3, k = slices.size();int prev_max = 0;vector<vector<int>> dp1(n,vector<int>(k,0));vector<vector<int>> dp2(n,vector<int>(k,0));dp1[0] = slices;dp2[0] = slices;for(i = 1; i < n; ++i){prev_max = 0;for(j = 0; j < k-1; ++j)//取第一块的情况，最后一个取不到，k-1{if(j-2 >= 0)//取第一块的情况prev_max = max(prev_max, dp1[i-1][j-2]);dp1[i][j] = prev_max + slices[j];}prev_max = 0;for(j = 1; j < k; ++j)//不取第一块的情况，从1开始{if(j-2 >= 1)//不取第一块的情况prev_max = max(prev_max, dp2[i-1][j-2]);dp2[i][j] = prev_max + slices[j];}}return max(*max_element(dp1[n-1].begin(),dp1[n-1].end()), *max_element(dp2[n-1].begin(),dp2[n-1].end()));}
};