[acwing周赛复盘] 第 92 场周赛20230225 补
一、本周周赛总结
- 有事去工地没打。第二天补的,这场好难啊。
- T1 模拟。
- T2 栈/先根遍历模拟构造。
- T3 并查集。
二、 4864. 多边形
链接: 4864. 多边形
1. 题目描述
太简单跳过。
三、4865. 有效类型
链接: 4865. 有效类型
1. 题目描述
2. 思路分析
本题两种做法,都写一下。
- 表达式的题先想到栈。
- 一个比较直观的做法是用栈模拟,检查栈顶三个值,满足:s[-3]==pair 且 s[-2]完整合法串 且 s[-1]是合法串完整合法串,则将栈顶这三个值合并成一个合法串。那么最后只要栈只剩一个元素就是最终合法结果。代码参见solve_tle()。
- 提交后TLE了。想想也是,字符串一直在移动,复杂度是结果长度的平方。
- 考虑这种做法的优化,其实没必要在合并的路上拼接,只需要记录每个单词中间添加的字符即可,最后拼起来。
- 观察结果对于原单词数组,每个单词右边都添加几个字符,那么构造一个ans数组,ans[i]代表第i个单词右边添加的字符们。
- 栈改为储存tuple(0/1,l,r),代表这个串是否合法、组合左边界单词下标、右边界单词下标。
- 那么显然遇到合法栈顶三个元素,s[-3]后要添加’<‘,s[-2]后要添加’,‘,s[-1]后添加’>'。参见solve1()
- 这里观察到只储存右边界即可,因此栈可以只存二元组。参见solve2().
- y总讲了可以先根遍历,我立马暂停视频去写代码了。写完过了,但是果然不如y总优雅。参考solve()
- 另外,acw的py设置递归深度会segment fault,惊呆了。只好改成@bootstrap写法。
3. 代码实现
# Problem: 有效类型
# Contest: AcWing
# URL: https://www.acwing.com/problem/content/4868/
# Memory Limit: 256 MB
# Time Limit: 1000 ms
import sys
import bisect
import random
import io, os
from bisect import *
from collections import *
from contextlib import redirect_stdout
from itertools import *
from array import *
from functools import lru_cache
from types import GeneratorType
from heapq import *
from math import sqrt, gcd, inf
if sys.version >= '3.8': # ACW没有comb
from math import comb
RI = lambda: map(int, sys.stdin.buffer.readline().split())
RS = lambda: map(bytes.decode, sys.stdin.buffer.readline().strip().split())
RILST = lambda: list(RI())
DEBUG = lambda *x: sys.stderr.write(f'{str(x)}\n')
MOD = 10 ** 9 + 7
# ms
def solve_tle():
n, = RI()
words = list(RS())
if words == ['int']:
return print('int')
p = words.count('pair')
it = words.count('int')
if p + 1 != it or words[0] != 'pair' or words[-1] != 'int':
return print('Error occurred')
s = []
for w in words:
s.append([0, w])
if w == 'int':
s[-1][0] = 1
if len(s) < 3:
continue
while len(s) >= 3 and s[-1][0] and s[-2][0] and s[-3][1] == 'pair':
_, y = s.pop()
_, x = s.pop()
s[-1] = [1, f'pair<{x},{y}>']
if len(s) == 1:
return print(s[0][1])
print('Error occurred')
# ms
def solve1():
n, = RI()
words = list(RS())
if words == ['int']:
return print('int')
p = words.count('pair')
it = words.count('int')
if p + 1 != it or words[0] != 'pair' or words[-1] != 'int':
return print('Error occurred')
s = []
ans = [''] * len(words)
for i, w in enumerate(words):
s.append([0, i, i])
if w == 'int':
s[-1][0] = 1
while len(s) >= 3 and s[-1][0] and s[-2][0] and s[-3][1] == s[-3][2] and words[s[-3][1]] == 'pair':
_, _, y = s.pop()
_, _, x = s.pop()
ans[s[-1][1]] += '<'
ans[y] += '>'
ans[x] += ','
s[-1] = [1, s[-1][1], y]
if len(s) == 1:
p = []
for x, y in zip(words, ans):
p.append(x)
p.append(y)
return print(''.join(p))
print('Error occurred')
# ms
def solve2():
n, = RI()
words = list(RS())
if words == ['int']:
return print('int')
p = words.count('pair')
it = words.count('int')
if p + 1 != it or words[0] != 'pair' or words[-1] != 'int':
return print('Error occurred')
s = []
ans = [''] * len(words)
for i, w in enumerate(words):
s.append([0, i])
if w == 'int':
s[-1][0] = 1
while len(s) >= 3 and s[-1][0] and s[-2][0] and s[-3][0] == 0:
_, y = s.pop()
_, x = s.pop()
ans[s[-1][1]] += '<'
ans[y] += '>'
ans[x] += ','
s[-1] = [1, y]
if len(s) == 1:
p = []
for x, y in zip(words, ans):
p.append(x)
p.append(y)
return print(''.join(p))
print('Error occurred')
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
# ms
def solve():
n, = RI()
words = list(RS())
n = len(words)
i = 0
ans = []
flag = True # 这是由于bootstrap做法不能提前return 要用flag去分支
@bootstrap
def dfs():
nonlocal i, flag
if i >= n:
i += 1
flag = False
if flag:
o = words[i]
i += 1
if o == 'int':
ans.append('int')
else:
ans.append('pair<')
yield dfs()
ans.append(',')
yield dfs()
ans.append('>')
yield
dfs()
if i != n:
return print('Error occurred')
print(''.join(ans))
if __name__ == '__main__':
solve()
四、4866. 最大数量
链接: 4866. 最大数量
1. 题目描述
2. 思路分析
并查集。
- 连边问题优先考虑并查集。
- 加边时,如果发现顶点x,y本身就是一个家族,那么可以省下一条边从外边家族连一条线进来组成更大家族。
- 考虑一个有s个顶点的家族,最大的度就是s-1,因为可以所有s-1个点都连同一个点。
- 因此可以按顺序加边,如果失败(本身是一个家族),记录省下的边数no_use。然后给所有家族size排序,选最大的另外no_use个连向最大家族即可。即求和最大的no_use+1个家族的size。那么只需要把所有家族size列出来排序即可。
- 注意选家族时技巧是判断i==find_father(i)。
- 总复杂度是O(d * n * logn)。但由于后边随着边增多,家族数会变小,排序可能用不满nlogn,但是遍历家族起码有个n。
- 可以从数据量看出来这个复杂度是合理的,如果只要n方,那么可能数据量是3000而不是1000。忽略并查集的最坏情况的log。
- 另外这里维护最大的k个家族size,考虑可以用懒删除大顶堆优化:
- 维护堆里的家族size,和一个已移除数据的Counter()。
- 当合并时,对cnt中添加要移除的两个size数字,并对堆中增加新的size数字。
- 查询最大k个数时,从堆中有效pop k次,如果这个数cnt[x]>0,则无效,重新pop,同时cnt[x]-1。
- 这些合法数还得再重新入堆。贼麻烦,常数上可能还不如sort,尤其是python。
- 用SortedList优化其实是个更好的主意,只需要两次remove和一个add。查询只需要sum([-k:])
- 他们可以省去遍历家族的n,用log代替排序的nlgn,但sum无法省去。
- 复杂度优化成d*d,即遍历d次,sum最多d-1个家族。
3. 代码实现
# Problem: 最大数量
# Contest: AcWing
# URL: https://www.acwing.com/problem/content/description/4869/
# Memory Limit: 256 MB
# Time Limit: 1000 ms
import sys
import bisect
import random
import io, os
from bisect import *
from collections import *
from contextlib import redirect_stdout
from itertools import *
from array import *
from functools import lru_cache
from types import GeneratorType
from heapq import *
from math import sqrt, gcd, inf
if sys.version >= '3.8': # ACW没有comb
from math import comb
RI = lambda: map(int, sys.stdin.buffer.readline().split())
RS = lambda: map(bytes.decode, sys.stdin.buffer.readline().strip().split())
RILST = lambda: list(RI())
DEBUG = lambda *x: sys.stderr.write(f'{str(x)}\n')
MOD = 10 ** 9 + 7
class DSU:
def __init__(self, n):
self.fathers = list(range(n))
self.size = [1] * n # 本家族size
self.edge_size = [0] * n # 本家族边数(带自环/重边)
self.n = n
self.setCount = n # 共几个家族
def find_fa(self, x):
fs = self.fathers
t = x
while fs[x] != x:
x = fs[x]
while t != x:
fs[t], t = x, fs[t]
return x
def union(self, x: int, y: int) -> bool:
x = self.find_fa(x)
y = self.find_fa(y)
if x == y:
self.edge_size[y] += 1
return False
if self.size[x] > self.size[y]:
x, y = y, x
self.fathers[x] = y
self.size[y] += self.size[x]
self.edge_size[y] += 1 + self.edge_size[x]
self.setCount -= 1
return True
# ms
def solve():
n, d = RI()
dsu = DSU(n + 1)
ans = []
no_use = 0
for i in range(1, d + 1):
x, y = RI()
if not dsu.union(x, y):
no_use += 1
s = [dsu.size[j] for j in range(1, n + 1) if j == dsu.find_fa(j)]
s.sort(reverse=True)
z = sum(s[:no_use + 1])
ans.append(z - 1)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
六、参考链接
- 无