新鲜出炉今天的周赛, 这场发挥了平均水平, 最终排名 55 (木有进前 50😭)
总结来说这场周赛题目质量不错, 前面两题没有特别简单, 后面两题也没有特别难, 相当推荐
[1441] 用栈操作构建数组
题目难度: 简单
题目描述
给你一个目标数组 target 和一个整数 n。每次迭代，需要从 list = {1,2,3…, n} 中依序读取一个数字。
请使用下述操作来构建目标数组 target ：
- Push：从 list 中读取一个新元素， 并将其推入数组中。
- Pop：删除数组中的最后一个元素。
- 如果目标数组构建完成，就停止读取更多元素。
题目数据保证目标数组严格递增，并且只包含 1 到 n 之间的数字。
请返回构建目标数组所用的操作序列。
题目数据保证答案是唯一的。
题目样例
示例 1
输入
target = [1,3], n = 3
输出
[“Push”,“Push”,“Pop”,“Push”]
解释
- 读取 1 并自动推入数组 -> [1]
- 读取 2 并自动推入数组，然后删除它 -> [1]
- 读取 3 并自动推入数组 -> [1,3]
示例 2
输入
target = [1,2], n = 4
输出
[“Push”,“Push”]
解释
只需要读取前 2 个数字就可以停止。
示例 3
输入
target = [1,2,3], n = 3
输出
[“Push”,“Push”,“Push”]
题目思考
- 这道题反其道行之, 给了目标数组, 让推导出操作序列
- 看上去只有两种情况: 在目标数组, 和不在目标数组
- 目标数组是递增的, 是否可以利用这一点?
解决方案
思路
- 存当前应该 push 的下标 cur
- 遍历目标数组
- 如果当前值 t 恰好等于 cur, 那么直接加个 push 操作, 同时更新下标为 t+1
- 否则对于[cur,t)之间的元素, 都应该一个 push 一个 pop 让它们进下 stack 就走…之后也不要忘了 push t, 以及更新下标
复杂度
- 时间复杂度 O(N): 需要遍历 target 数组
- 空间复杂度 O(1): 只使用了几个变量
代码
Python 3
class Solution:
def buildArray(self, target: List[int], n: int) -> List[str]:
res = []
cur = 1
for t in target:
if t != cur:
# t一定大于cur
res.extend(['Push', 'Pop'] * (t - cur))
res.append('Push')
cur = t + 1
return res
C++
class Solution {
public:
vector<string> buildArray(vector<int>& target, int n) {
vector<string> res;
int curr = 1;
for (auto t : target) {
if (t != curr) {
for (int i = 0; i < t - curr; ++i) {
res.push_back("Push");
res.push_back("Pop");
}
}
res.push_back("Push");
curr = t + 1;
}
return res;
}
};
[1442] 形成两个异或相等数组的三元组数目
题目难度: 中等
题目描述
给你一个整数数组 arr 。
现需要从数组中取三个下标 i、j 和 k ，其中 (0 <= i < j <= k < arr.length) 。
a 和 b 定义如下：
- a = arr[i] ^ arr[i + 1] ^ … ^ arr[j - 1]
- b = arr[j] ^ arr[j + 1] ^ … ^ arr[k]
注意：^ 表示 按位异或 操作。
请返回能够令 a == b 成立的三元组 (i, j , k) 的数目。
题目样例
示例 1
输入
arr = [2,3,1,6,7]
输出
4
解释
满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)
示例 2
输入
arr = [2,3]
输出
0
解释
没有满足条件的 a 和 b
示例 3
输入
arr = [1,1,1,1,1]
输出
10
题目思考
- 题目很直白, 直接暴力三重循环可以吗?
- 是否可以通过预处理进行优化?
解决方案
思路
- 直接三重循环的做法很直白, 但其复杂度过高 (python 3 需要 5000ms…), 这里就忽略了
- 这里提供一种预处理的方法 (python 3 使用这种方法只需要 196ms):
- 先拿到所有区间的异或结果
- 将结果存入字典中作为 key
- 字典的 value 也是一个字典, key 是区间起始下标, value 是区间结束下标集合
- 这样可以只需遍历每个起始下标 s 对应的终点下标 e 集合, 如果 e+1 也在当前字典中, 那么 res 就加上 e+1 对应的终点下标集合长度
复杂度
- 时间复杂度 O(N^2): 预处理需要 O(N^2), 求结果也是 O(N^2)
- 空间复杂度 O(N^2): 字典中存了 O(N^2)的下标元素
代码
Python 3
class Solution:
def countTriplets(self, arr: List[int]) -> int:
n = len(arr)
d = collections.defaultdict(dict)
# 预处理字典 {a:{s:[e1,e2,...]}}
for i in range(n):
a = 0
for j in range(i, n):
a^=arr[j]
if i not in d[a]:
d[a][i] = []
d[a][i].append(j)
res = 0
# 这里虽然表面是三重循环
# 但实际k*s才相当于原先的数组元素数目N
# 所以复杂度还是O(N^2)
for k in d:
for s in d[k]:
for e in d[k][s]:
if e+1 in d[k]:
res+=len(d[k][e+1])
return res
C++
class Solution {
public:
int countTriplets(vector<int>& arr) {
unordered_map<int, unordered_map<int, unordered_set<int>>> d;
for (int i = 0; i < arr.size(); ++i) {
int a = 0;
for (int j = i; j < arr.size(); ++j) {
a ^= arr[j];
d[a][i].insert(j);
}
}
int res = 0;
for (auto& k : d) {
for (auto& s : k.second) {
for (auto e : s.second) {
if (k.second.find(e+1) != k.second.end()) {
res += d[k.first][e+1].size();
}
}
}
}
return res;
}
};
[1443] 收集树上所有苹果的最少时间
题目难度: 中等
题目描述
给你一棵有 n 个节点的无向树，节点编号为 0 到 n-1 ，它们中有一些节点有苹果。通过树上的一条边，需要花费 1 秒钟。你从 节点 0 出发，请你返回最少需要多少秒，可以收集到所有苹果，并回到节点 0 。
无向树的边由 edges 给出，其中 edges[i] = [fromi, toi] ，表示有一条边连接 from 和 toi 。除此以外，还有一个布尔数组 hasApple ，其中 hasApple[i] = true 代表节点 i 有一个苹果，否则，节点 i 没有苹果。
题目样例
示例 1
输入
n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,true,true,false]
输出
8
解释
上图展示了给定的树，其中红色节点表示有苹果。一个能收集到所有苹果的最优方案由绿色箭头表示。
示例 2
输入
n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,false,true,false]
输出
6
解释
上图展示了给定的树，其中红色节点表示有苹果。一个能收集到所有苹果的最优方案由绿色箭头表示。
示例 3
输入
n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,false,false,false,false,false]
输出
0
题目思考
- 这道题要用什么思路呢? 贪心? DFS? BFS?
- 仔细观察示例图和结果, 是否有什么发现?
解决方案
思路
- 要收集到所有苹果, 充要条件是每个有苹果的节点都要走一遍
- 对于那些本身没有苹果, 且子树没有苹果的节点, 完全不需要走到它们
- 所以如果能够统计出所有自身或者子树有苹果的节点, 然后把这些节点都走一遍, 就是最优方案
- 假设节点数为 n, 由于题目是个树, 所以这些节点构成的路径数目是 n-1, 最优情况就是每个路径走 2 次, 一来一回, 结果就是 2*(n-1)
- 如何求自身或者子树有苹果的节点呢? 可以想到使用递归, 结果返回当前节点及子树是否有苹果, 然后逐层上去即可
复杂度
- 时间复杂度 O(N): 初始化路径和递归各需要遍历每个节点一次
- 空间复杂度 O(N): 使用了一个字典, 字典元素总数为节点数目, 还有递归的栈的消耗
代码
Python 3
class Solution:
def minTime(self, n: int, edges: List[List[int]],
hasApple: List[bool]) -> int:
# 初始化路径
maps = collections.defaultdict(list)
for e in edges:
maps[e[0]].append(e[1])
def dfs(i):
selfOrChildHasApple = hasApple[i]
for nex in maps[i]:
selfOrChildHasApple |= dfs(nex)
if not selfOrChildHasApple:
# 从字典中移除自身或子树都没有苹果的节点
del maps[i]
return selfOrChildHasApple
dfs(0)
# 字典个数即为最终有效节点的个数
# 但是有可能有效节点为0, 所以需要max一下
return max(0, 2 * (len(maps) - 1))
C++
class Solution {
public:
int minTime(int n, vector<vector<int>>& edges, vector<bool>& hasApple) {
for (auto& entry : edges) {
maps[entry[0]].push_back(entry[1]);
}
hasAppleHelper(0, hasApple);
return maps.empty() ? 0 : 2 * (maps.size() - 1);
}
private:
bool hasAppleHelper(int idx, vector<bool>& hasApple) {
bool selfOrChildHasApple = hasApple[idx];
for (auto i : maps[idx]) {
selfOrChildHasApple = hasAppleHelper(i, hasApple) || selfOrChildHasApple;
}
if (!selfOrChildHasApple) {
maps.erase(idx);
}
return selfOrChildHasApple;
}
private:
unordered_map<int, vector<int>> maps;
};
[1444] 切披萨的方案数
题目难度: 困难
题目描述
给你一个 rows x cols 大小的矩形披萨和一个整数 k ，矩形包含两种字符： ‘A’ （表示苹果）和 ‘.’ （表示空白格子）。你需要切披萨 k-1 次，得到 k 块披萨并送给别人。
切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置，将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人，如果水平地切，那么需要把上面的部分送给一个人。在切完最后一刀后，需要把剩下来的一块送给最后一个人。
请你返回确保每一块披萨包含 至少 一个苹果的切披萨方案数。由于答案可能是个很大的数字，请你返回它对 10^9 + 7 取余的结果。
- 1 <= rows, cols <= 50
- rows == pizza.length
- cols == pizza[i].length
- 1 <= k <= 10
- pizza 只包含字符 ‘A’ 和 ‘.’ 。
题目样例
示例 1
输入
pizza = [“A…”,“AAA”,"…"], k = 3
输出
3
解释
上图展示了三种切披萨的方案。注意每一块披萨都至少包含一个苹果。
示例 2
输入
pizza = [“A…”,“AA.”,"…"], k = 3
输出
1
解释
只能横切一刀, 竖切一刀, 再横切一刀
示例 3
输入
pizza = [“A…”,“A…”,"…"], k = 1
输出
1
题目思考
- 注意到这道题的数据规模很小, 是不是可以利用多个状态记忆化搜索或动态规划?
- 状态的选择: 每次分出去的都是上面或者左边的, 是否可以利用这一点?
- 可否通过一些预处理来加速运算呢?
解决方案
思路
- 记忆化搜索/动态规划
- memo[r,c,p]表示矩形[(r,c), (rows-1, cols-1)]分给 p 个人的方案数
- 那么 memo[r,c,p] = sum(memo[nexr, c, p-1]) + sum(memo[r, nexc, p-1])
- r+1<=nexr<rows
- c+1<=nexc<cols
- 且[r, nexr)以及[c, nexc]之间的部分必须要有苹果分给当前的人, 否则当前的人就拿不到苹果了
- 至于怎么求[r, nexr)以及[c, nexc]之间的苹果数, 如果每次递归的时候都重新计算, 那太慢了大概率会超时吧…这部分完全可以通过事先预处理求得
- 所以额外定义几个字典, rightcnt/downcnt/cnt 分别表示当前坐标右边一行, 下边一列, 以及右下矩形的苹果数目, 右下矩形的苹果数目可以用于剪枝, 当数目<所需人数时直接返回 0 即可
复杂度
- 时间复杂度 O(rows*cols*k*(rows+cols))): 需要搜索 rows*cols*k 个状态, 而且搜索时要对接下来的 r 或者 c 求和, 根据本题数据量, 就是 50*50*10*100, 还算可以接受(如果有更优解欢迎指出 🤩)
- 空间复杂度 O(rows*cols*k): memo 的元素个数
代码
Python 3
class Solution:
def ways(self, pizza: List[str], k: int) -> int:
mod = 10**9 + 7
memo = {}
rightdowncnt = collections.defaultdict(int)
downcnt = collections.defaultdict(int)
rightcnt = collections.defaultdict(int)
rows, cols = len(pizza), len(pizza[0])
# 预处理, 求三种cnt字典
for c in range(cols):
for r in range(rows)[::-1]:
downcnt[r, c] = 1 if pizza[r][c] == 'A' else 0
downcnt[r, c] += downcnt[r + 1, c]
for r in range(rows):
for c in range(cols)[::-1]:
rightcnt[r, c] = 1 if pizza[r][c] == 'A' else 0
rightcnt[r, c] += rightcnt[r, c + 1]
for r in range(rows)[::-1]:
for c in range(cols)[::-1]:
rightdowncnt[r, c] = 1 if pizza[r][c] == 'A' else 0
rightdowncnt[r,
c] += rightdowncnt[r + 1, c] + rightcnt[r, c + 1]
def dfs(r, c, p):
# 递归出口
if r == rows or c == cols:
return 0
if (r, c, p) not in memo:
if rightdowncnt[r, c] < p:
# 剪枝
memo[r, c, p] = 0
elif p == 1:
# 只有1人时方案数只能为1
memo[r, c, p] = 1
else:
sm = 0
cnt = 0
# 状态转移, 求接下来所有可能的方案数之和
# 注意取模
for nexr in range(r+1, rows):
cnt += rightcnt[nexr-1, c]
if cnt > 0:
sm = (sm + dfs(nexr, c, p - 1)) % mod
cnt = 0
for nexc in range(c+1, cols):
cnt += downcnt[r, nexc-1]
if cnt > 0:
sm = (sm + dfs(r, nexc, p - 1)) % mod
memo[r, c, p] = sm
return memo[r, c, p]
res = dfs(0, 0, k)
return res
C++
class Solution {
public:
int ways(vector<string>& pizza, int k) {
int rows = pizza.size();
int cols = pizza[0].size();
vector<vector<int>> downcnt = vector<vector<int>>(rows+1, vector<int>(cols+1, 0));
vector<vector<int>> rightcnt = vector<vector<int>>(rows+1, vector<int>(cols+1, 0));
vector<vector<int>> rightdowncnt = vector<vector<int>>(rows+1, vector<int>(cols+1, 0));
vector<vector<vector<int>>> memo = vector<vector<vector<int>>>(rows+1, vector<vector<int>>(cols+1, vector<int>(k+1, -1)));
for (int c = 0; c < cols; ++c) {
for (int r = rows - 1; r >= 0; --r) {
downcnt[r][c] = downcnt[r+1][c] + (pizza[r][c] == 'A' ? 1 : 0);
}
}
for (int r = 0; r < rows; ++r) {
for (int c = cols - 1; c >= 0; --c) {
rightcnt[r][c] = rightcnt[r][c+1] + (pizza[r][c] == 'A' ? 1 : 0);
}
}
for (int r = rows - 1; r >= 0; --r) {
for (int c = cols - 1; c >= 0; --c) {
rightdowncnt[r][c] = rightdowncnt[r+1][c] + rightcnt[r][c];
}
}
long long mod = 1e9+7;
function<int(int, int, int)> dfs = [&](int r, int c, int p) {
if (r == rows || c == cols) {
return 0;
}
if (memo[r][c][p] == -1) {
if (rightdowncnt[r][c] < p) {
memo[r][c][p] = 0;
} else if (p == 1) {
memo[r][c][p] = 1;
} else {
int sm = 0;
int cnt = 0;
for (int i = r+1; i < rows; ++i) {
cnt += rightcnt[i-1][c];
if (cnt > 0) {
sm = (sm + dfs(i, c, p-1)) % mod;
}
}
cnt = 0;
for (int i = c+1; i < cols; ++i) {
cnt += downcnt[r][i-1];
if (cnt > 0) {
sm = (sm + dfs(r, i, p-1)) % mod;
}
}
memo[r][c][p] = sm;
}
}
return memo[r][c][p];
};
return dfs(0, 0, k);
}
};
大家可以在下面这些地方找到我~😊
我的公众号: 每日精选算法题, 欢迎大家扫码关注~😊
673
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
