[牛客小白赛复盘] 牛客小白月赛74
总结
- 做了5题就下班跑路了哈哈,路上看了FG题面，G不会证明。
- A 模拟。
- B 模拟。
- C 贪心+哈希表。
- D 贪心排序
- E 分类讨论，数学
- F 二分答案+并查集
- G 单调栈+贪心+树状数组RURQ
A 简单的整除
链接: [简单的整除](https://ac.nowcoder.com/acm/contest/59284/A
1. 题目描述
2. 思路分析
- 模拟。
3. 代码实现
# Problem: 简单的整除
# Contest: NowCoder
# URL: https://ac.nowcoder.com/acm/contest/59284/A
# Memory Limit: 524288 MB
# Time Limit: 2000 ms
import sys
import random
from types import GeneratorType
import bisect
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, reduce
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')
# print = lambda d: sys.stdout.write(str(d) + "\n") # 打开可以快写，但是无法使用print(*ans,sep=' ')这种语法,需要print(' '.join(map(str, p)))，确实会快。
DIRS = [(0, 1), (1, 0), (0, -1), (-1, 0)] # 右下左上
DIRS8 = [(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0),
(-1, 1)] # →↘↓↙←↖↑↗
RANDOM = random.randrange(2**62)
MOD = 10**9 + 7
PROBLEM = """
"""
def lower_bound(lo: int, hi: int, key):
"""由于3.10才能用key参数，因此自己实现一个。
:param lo: 二分的左边界(闭区间)
:param hi: 二分的右边界(闭区间)
:param key: key(mid)判断当前枚举的mid是否应该划分到右半部分。
:return: 右半部分第一个位置。若不存在True则返回hi+1。
虽然实现是开区间写法，但为了思考简单，接口以[左闭,右闭]方式放出。
"""
lo -= 1 # 开区间(lo,hi)
hi += 1
while lo + 1 < hi: # 区间不为空
mid = (lo + hi) >> 1 # py不担心溢出，实测py自己不会优化除2，手动写右移
if key(mid): # is_right则右边界向里移动，目标区间剩余(lo,mid)
hi = mid
else: # is_left则左边界向里移动，剩余(mid,hi)
lo = mid
return hi
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
def solve():
x, = RI()
print("YES" if x % 2 == 0 or x % 3 == 0 or x % 5 == 0 or x % 7 == 0 else 'NO')
if __name__ == '__main__':
t = 0
if t:
t, = RI()
for _ in range(t):
solve()
else:
solve()
B 整数划分
链接: 整数划分
1. 题目描述
2. 思路分析
- 由于要最小字典序，那么前边就是1 2 3 4…连续的。
- 那么为了不使用重复数，最后一个数一定要>倒数第二个数。拆分时要注意。
3. 代码实现
def solve():
n, = RI()
ans = []
i = 1
while True:
if n-i > i:
ans.append(i)
n -= i
i += 1
else:
ans.append(n)
break
print(*ans)
C 传送阵
链接: 传送阵
1. 题目描述
2. 思路分析
- 题目看似唬人，仔细想想就会发现，每次花费代价可以经过一类数字所有。而且一定可以移动到边界上，去下一个数。
- 那么所有数字去重看看有多少种即可。
3. 代码实现
def solve():
n,m = RI()
s = set()
for _ in range(n):
r = RILST()
s|=set(r)
print(len(s))
D 修改后的和
链接: 修改后的和
1. 题目描述
2. 思路分析
- 每次操作都会把这个数变0，换言之每个数只需要操作1次。而它的价值是固定的就是v*len。
- 那么把每个操作的价值排序，从大到小取m个即可。
- 你可能会担心操作的顺序会不会影响后续的价值，那么从后往前操作即可不会影响。
3. 代码实现
def solve():
n, m = RI()
a = RILST()[::-1]
p = []
for i, v in enumerate(a, start=1):
if v > 0:
p.append(v * i)
p.sort(reverse=True)
print(sum(a) - sum(p[:m]))
E 幼稚园的树2
链接: 幼稚园的树2
1. 题目描述
2. 思路分析
我仿佛在做小学奥数。
- 对每颗树的答案单独计算，疯狂分类讨论即可。
- 如果m天根本长不过k，那么可以直接计算。
- 否则，先计算第一次长过k需要几天：
- 由于必须长过k，即至少要到k+1，那么要长k+1-hi，速度是ai,用上取整公式算出第一次被剪成b的花费天数one。
- 那么还剩p=m-1-one天可以长，从b开始。
- 显然，每隔几天就会超过k，变成b，这个周期是per=ceil((k+1-b)/ai)。
- 那么实际有效的天数就是p%per。
- ans[i]=b+p*ai
3. 代码实现
# ms
def solve():
n,m,k,b = RI()
h = RILST()
a = RILST()
ans = [0]*n
for i,(x,y) in enumerate(zip(h,a)):
if x + y*(m-1) <= k:
ans[i] = x + y*(m-1)
continue
one = (k+1-x+y-1)//y
p = m -1 - one # 还能长p天
if p == 0:
ans[i] = b
continue
per = (k+1-b+y-1)//y # 每per天会被剪到b
p %= per
ans[i] = b + p*y
print(*ans)
F 最便宜的构建
链接: 最便宜的构建
1. 题目描述
2. 思路分析
题目很长，抓住关键词最小化最大值。
- 二分答案。
- 由于边不怕加多，直接尽可能的加边，则要求的集合更有可能连通。
- 最大边越大，能加的边越多，更可能连通；最大边越小，加的边少，越不会连通；满足二段性。
- check时，把小于mid的边全部加进并查集，然后检查每个集合的连通性即可。
- 答案的上下界可以直接写0,1e9。也可以写min(w),max(w)
3. 代码实现
# ms
def lower_bound(lo: int, hi: int, key):
"""由于3.10才能用key参数，因此自己实现一个。
:param lo: 二分的左边界(闭区间)
:param hi: 二分的右边界(闭区间)
:param key: key(mid)判断当前枚举的mid是否应该划分到右半部分。
:return: 右半部分第一个位置。若不存在True则返回hi+1。
虽然实现是开区间写法，但为了思考简单，接口以[左闭,右闭]方式放出。
"""
lo -= 1 # 开区间(lo,hi)
hi += 1
while lo + 1 < hi: # 区间不为空
mid = (lo + hi) >> 1 # py不担心溢出，实测py自己不会优化除2，手动写右移
if key(mid): # is_right则右边界向里移动，目标区间剩余(lo,mid)
hi = mid
else: # is_left则左边界向里移动，剩余(mid,hi)
lo = mid
return hi
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.set_count = 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，需要干掉这个；实际上上边改成find_fa后，按轶合并没必要了，所以可以常关
# x, y = y, x
self.fathers[x] = y
self.size[y] += self.size[x]
self.edge_size[y] += 1 + self.edge_size[x]
self.set_count -= 1
return True
# ms
def solve():
n, m = RI()
es = []
for _ in range(m):
u, v, w = RI()
es.append((w, u - 1, v - 1))
es.sort()
k, = RI()
s = []
for _ in range(k):
si, *ss = RI()
s.append(ss)
def ok(x):
dsu = DSU(n)
for w, u, v in es:
if w > x: break
dsu.union(u, v)
for ss in s:
p = dsu.find_fa(ss[0] - 1)
for u in ss[1:]:
if dsu.find_fa(u - 1) != p:
return False
return True
print(lower_bound(min(es)[0], max(es)[0], ok))
G 跳石头，搭梯子
链接: 跳石头，搭梯子
1. 题目描述
2. 思路分析
过是过了，排序贪心那步没证出来。
- 一看搭梯子的条件是中间的梯子必须短于两段，那么考虑单调递减栈。
- 单减栈出栈时，当前i是栈顶右边第一个大于栈顶的位置。
- 入栈时，栈顶是当前i左边第一个大于i的位置。
- 意味着中间的数都是小于两端，可以搭梯子。
- 注意不要搭相邻的两个数。
- 找到所有梯子，考虑用类似D题的方法，计算每个梯子的贡献和原本总花费，用总花费减去最优的m个梯子即可。
- 如何计算贡献。
- 显然贡献=这段的原花费-梯子花费。
- 按贡献排序，取最大的m个梯子，但梯子不能重叠，直到取到m个梯子即可。
- 这里不知道怎么证明，但是ac。直觉上：
- 由于花费是abs的，因此越宽的梯子越nb，毕竟两端是超过中间的，它们天然的会排在前边。
- 如何计算贡献。
- 剩下的问题是怎么快速判断重叠，由于py没有有序集合，我贴了个RURQ的树状数组，它可以用log的时间操作。
- 注意梯子两端是可以重叠的，是中间不能重叠，那么选择把左端点右移一位，正好可以给BIT用。
3. 代码实现
class BinIndexTreeRURQ:
"""树状数组的RURQ模型"""
def __init__(self, size_or_nums): # 树状数组,区间加区间求和，下标需要从1开始
# 如果size 是数字，那就设置size和空数据；如果size是数组，那就是a
if isinstance(size_or_nums, int):
self.size = size_or_nums
self.c = [0 for _ in range(self.size + 5)]
self.c2 = [0 for _ in range(self.size + 5)]
else:
self.size = len(size_or_nums)
self.c = [0 for _ in range(self.size + 5)]
self.c2 = [0 for _ in range(self.size + 5)]
for i, v in enumerate(size_or_nums):
self.add_interval(i + 1, i + 1, v)
def add_point(self, c, i, v): # 单点增加,下标从1开始;不支持直接调用，这里增加的是差分数组的单点,同步修改c2
while i <= self.size:
c[i] += v
i += -i & i
def sum_prefix(self, c, i): # 前缀求和，下标从1开始；不支持直接调用，这里求和的是差分数组的前缀和;传入c决定怎么计算，但是不要直接调用 无视吧
s = 0
while i >= 1:
s += c[i]
i -= -i & i
return s
def add_interval(self, l, r, v): # 区间加，下标从1开始，把[l,r]闭区间都加v
self.add_point(self.c, l, v)
self.add_point(self.c, r + 1, -v)
self.add_point(self.c2, l, (l - 1) * v)
self.add_point(self.c2, r + 1, -v * r)
def sum_interval(self, l, r): # 区间求和，下标从1开始，返回闭区间[l,r]上的求和
return self.sum_prefix(self.c, r) * r - self.sum_prefix(self.c2, r) - self.sum_prefix(self.c, l - 1) * (
l - 1) + self.sum_prefix(self.c2, l - 1)
def query_point(self, i): # 单点询问值，下标从1开始，返回i位置的值
return self.sum_prefix(self.c, i)
def lowbit(self, x):
return x & -x
"""
先用单调栈求出所有可以搭的桥
记录每个桥如果搭，贡献是多少，显然是 原花费-过桥的花费
把桥按贡献排序，从大到小取m个，但不能重叠
答案就是 原花费-桥的贡献
证明：请木木大佬补充
"""
# 1113ms
def solve():
n, m = RI()
a = RILST()
ans = 0
p = [0] * n # 相邻差的前缀和
for i in range(1, n):
d = abs(a[i] - a[i - 1])
ans += d
p[i] = d + p[i - 1]
# print(p)
st = []
lines = []
for i, v in enumerate(a):
while st and a[st[-1]] < v:
j = st[-1]
if j + 1 < i:
lines.append((abs(v - a[j]) - (p[i] - p[j]), j, i)) # j~i可以搭梯子
st.pop()
if st and st[-1] + 1 < i:
j = st[-1]
if j + 1 < i:
lines.append((abs(v - a[j]) - (p[i] - p[j]), j, i)) # j~i可以搭梯子
st.append(i)
lines.sort()
tree = BinIndexTreeRURQ(n)
for w, l, r in lines:
if not m:
break
if tree.sum_interval(l + 1, r) == 0:
ans += w
m -= 1
tree.add_interval(l + 1, r, 1)
# print(lines)
print(ans)
六、参考链接
- 无
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
