LeetCode221场周赛题解
Github地址
1704. 判断字符串的两半是否相似
题意：判断给定的字符串两半中元音字符出现的次数是否相同
思路：遍历字符串的两边，统计其中元音字符出现的次数分别为cnt1，cnt2，最后返回cnt1==cnt2
class Solution {
public:
bool halvesAreAlike(string s) {
unordered_set<char> st{
'a','e','i','o','u','A','E','I','O','U'};
int mid = s.size() / 2;
int cnt1 = 0, cnt2 = 0;
for (int i = 0, j = 0; i < mid; i++, j++) {
if (st.count(s[i])) cnt1++;
if (st.count(s[mid + j])) cnt2++;
}
return cnt1 == cnt2;
}
};
1705. 吃苹果的最大数目
题意：有一棵特殊的苹果树，一连 n 天，每天都可以长出若干个苹果。在第 i 天，树上会长出 apples[i] 个苹果，这些苹果将会在 days[i] 天后（也就是说，第 i + days[i] 天时）腐烂，变得无法食用。也可能有那么几天，树上不会长出新的苹果，此时用 apples[i] == 0 且 days[i] == 0 表示。
你打算每天 最多 吃一个苹果来保证营养均衡。注意，你可以在这 n 天之后继续吃苹果。
给你两个长度为 n 的整数数组 days 和 apples ，返回你可以吃掉的苹果的最大数目
示例 1：
输入：apples = [1,2,3,5,2], days = [3,2,1,4,2]
输出：7
解释：你可以吃掉 7 个苹果：
- 第一天，你吃掉第一天长出来的苹果。
- 第二天，你吃掉一个第二天长出来的苹果。
- 第三天，你吃掉一个第二天长出来的苹果。过了这一天，第三天长出来的苹果就已经腐烂了。
- 第四天到第七天，你吃的都是第四天长出来的苹果。
思路：考虑当前为第i天，且手中有多个不同时间腐烂的苹果，那么这一天应该吃掉哪个苹果呢？直觉告诉我们，应该吃掉最快腐烂的苹果，因为更慢腐烂的苹果可以留到更后的时间点再吃，而快要腐烂的苹果只有先吃才能使最后腐烂“浪费”的苹果最少。根据这个思路，要根据腐烂的时间维护苹果的**“顺序”，且每次只吃最快腐烂的那个苹果，所以可以使用根据腐烂时间维护优先队列**，使用小顶堆，每次从堆顶取得最快腐烂的苹果，如果没有腐烂，则吃掉一个最快腐烂的苹果。
细节：注意，不能将所有苹果先加入队列再吃，这样会导致第i天可能会吃掉第j天的苹果，ij天的苹果在第i天还不存在。
class Solution {
public:
int eatenApples(vector<int>& apples, vector<int>& days) {
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
int n = apples.size();
int d = 0;
int res = 0;
for (int i = 0; i < n; i++, d++) {
if (apples[i] != 0 && days[i] != 0) //放入苹果
pq.push({
i + days[i], apples[i]});
while (pq.size()) {
auto t = pq.top();pq.pop();
if (t.first <= d) continue;//苹果已经腐烂
if (t.first > d) {
//说明有还未腐烂的苹果
if (t.second == 0) continue;
res++;//吃一个苹果
t.second--;
if (t.second != 0)
pq.push(t);//吃完之后修改苹果数量重新入队
break;
}
}
}
while (pq.size()) {
//在第n天之后，还可以继续吃苹果
auto t = pq.top(); pq.pop();
if (t.first <= d) continue;
if (t.first > d) {
//一定可以吃苹果
int cnt = min(t.first - d, t.second);//一次尽可能吃最多最快腐烂的苹果
d += cnt;
res += cnt;
}
}
return res;
}
};
1706. 球会落何处
题目见原链接
思路：grid为整个箱子的状态，大小为m x n，对于每一个格子内的球，模拟其走过的路径，这样时间复杂度为O(m*n)，需要注意的一点是，假设当前小球位于第i行，第j列，要根据grid[i][j]的情况来判断是要和grid[i][j + 1]还是和grid[i][j - 1]进行比较，如果grid[i][j]向右下方倾斜则要和grid[i][j + 1]比较，反之需要和grid[i][j]比较，如下面代码第13行和第20行。
class Solution {
public:
vector<int> findBall(vector<vector<int>>& grid) {
int m = grid.size(), n = grid[0].size();
vector<int> res(n, -1);
for (int i = 0; i < n; i++) {
int x = 0, y = i;//x，y为起始的位置
while (x < m && y < n) {
int z = grid[x][y];
if (z == 1) {
//如果当前单元格向右
if (y == n - 1) break; //被右边界卡住
if (grid[x][y + 1] == 1) {
x++;
y++;
}else break;//在中间某个位置被卡住
}
if (z == -1) {
//如果当前单元格向左
if (y == 0) break;//被左边界卡住
if (grid[x][y - 1] == -1) {
x++;
y--;
} else break;//在中间某个位置被卡住
}
}
if (x == m) res[i] = y;//到达了底部
}
return res;
}
};
1707. 与数组中元素的最大异或值
题意：
给你一个由非负整数组成的数组 nums 。另有一个查询数组 queries ，其中 queries[i] = [xi, mi] 。
第 i 个查询的答案是 xi 和任何 nums 数组中不超过 mi 的元素按位异或（XOR）得到的最大值。换句话说，答案是 max(nums[j] XOR xi) ，其中所有 j 均满足 nums[j] <= mi 。如果 nums 中的所有元素都大于 mi，最终答案就是 -1 。
返回一个整数数组 answer 作为查询的答案，其中 answer.length == queries.length 且 answer[i] 是第 i 个查询的答案。
示例 1：
输入：nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]
输出：[3,3,7]
解释：
1) 0 和 1 是仅有的两个不超过 1 的整数。0 XOR 3 = 3 而 1 XOR 3 = 2 。二者中的更大值是 3 。
2) 1 XOR 2 = 3.
3) 5 XOR 2 = 7.
思路：首先这题的思路基于一个经典的例题，421. 数组中两个数的最大异或值，这题是求给定一个数ai和数组中任意一个数aj异或，所得的值最大为多少？首先考虑这个问题如何求解，考虑异或运算的性质，两个相反的位异或必定为1，基于这样的性质，如果aj的高位和ai不同，那么其异或之后所得结果中，该位必定为1，然后使用贪心策略，最后aj与ai异或后所得值最大的aj一定具有这样的性质，其二进制表示的高位尽可能的和ai的二进制表示的对应位不同，这样的aj就是其二进制表示的前缀尽可能和ai的二进制表示的对应位不同，可以使用Trie树存储每个数的二进制表示前缀，查找异或结果的最大值时，就是在Trie数中尽可能走一条和ai二进制表示相反的路径。
这题在上一题中额外添加了一个限制，就是aj并不是数组中的所有数，而是小于某个数xi，可以通过离线处理的方法将这个问题转化为上一个问题。具体做法就是将所有查询按xi排序，当查询到xi时，把数组中所有小于xi的aj插入Trie树中，这样这个问题就等价于上一个问题，转化过程如下面的代码第49行。
static const int N = 1e5+10;
struct Node {
int num, m, idx;
bool operator < (Node &r) {
return m < r.m;
}
}q[N];
class Solution {
public:
int son[31*N][2], idx = 0;
void insert(int x) {
//Trie的插入
int p = 0;
for (int i = 30; i >= 0; i--) {
int u = x >> i & 1;
if (!son[p][u]) son[p][u] = ++idx;
p = son[p][u];
}
}
int query(int x) {
//Trie查找算法，返回Trie中任意数与x异或结果的最大值
if (!idx) return -1;
int p = 0, ret = 0;
for (int i = 30; i >= 0; i--) {
int u = x >> i & 1;
if (son[p][!u]) {
ret |= 1 << i;
p = son[p][!u];
} else {
p = son[p][u];
}
}
return ret;
}
vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) {
int n = nums.size(), m = queries.size();
sort(nums.begin(), nums.end());//nums排序
for (int i = 0; i < queries.size(); i++) {
//queries按xi排序
q[i] = {
queries[i][0], queries[i][1], i};
}
sort(q, q + m);
vector<int> answer(m, -1);
int idx = 0;
for (int i = 0; i < m; i++) {
while (idx < n && nums[idx] <= q[i].m) insert(nums[idx++]);//离线处理
answer[q[i].idx] = query(q[i].num);//查询
}
return answer;
}
};