牛客周赛 Round 52

A 两数之和

# 读取整数 z
z = int(input())

# 检查 z 是否大于 2
if z > 2:
    print("YES")
    # 输出两个不同的正整数 x 和 y
    print(1, z - 1)
else:
    print("NO")

B 小红装匣子

# 循环次数
t = int(input())
for _ in range(t):
    # 读取输入值：a, b, n
    a, b, n = map(int, input().split())
    # 计算可以减少的最大n的值，每3次减少成本是2的b的最大倍数
    max_reduction = min(n // 3, b // 2) * 3
    # 更新n的值
    n -= max_reduction
    # 如果剩余的n小于等于a，则可以完成任务
    if a >= n:
        print("YES")
    else:
        print("NO")

C 小红的数字对对碰

# 导入 heapq 模块
import heapq

# 读取整数 n（元素数量）
n = int(input())
# 读取整数列表（元素值）
nums = list(map(int, input().split()))

a, b = 0, 0  # a 为非负数数量，b 为负数数量
mp = {}  # 用于统计每个非负数出现的次数
cnt = 0  # 统计成对出现的非负数的数量

# 遍历元素进行计数
for x in nums:
    if x >= 0:  # 对非负数进行处理
        a += 1
        mp[x] = mp.get(x, 0) + 1
        if mp[x] % 2 == 0:  # 如果当前数出现了偶数次
            cnt += 2
    else:  # 负数直接计数
        b += 1

# 调整 n 的值，减去成对非负数的总数
n -= cnt
# 同样减去成对的非负数数量，更新 a
a -= cnt

# 比较非负数和负数的数量，输出最终结果
if a > b:
    print(n - 2 * b)  # 如果非负数多，输出调整后的差值
else:
    print((b - a) % 2)  # 如果负数多或相等，输出它们数量差的奇偶性

D 小红的最大字典序

from heapq import heappop, heappush, heapify

n = int(input())  # 读取输入的行数
a = input().split()  # 读取每行输入并分割成字符串列表

ans = ''  # 初始化答案字符串
# 创建一个最小堆，其中每个元素是字符串中每个字符的负值（用于创建最大堆）以及一个标记值 1
heap = [list(-int(char) for char in ai) + [1] for ai in a]
heapify(heap)  # 将列表转换成堆结构

while len(heap) > 0:  # 当堆中还有元素时执行循环
    ls = heappop(heap)  # 弹出堆中的最小元素（实际上是最大的元素，因为使用了负值）
    ans += str(-ls.pop(0))  # 将弹出的数值转为正数并添加到答案字符串中
    if len(ls) > 1:  # 如果当前列表中还有元素（除去标记值 1）
        heappush(heap, ls)  # 将剩余部分重新推入堆中

print(ans)  # 输出最终的答案字符串

E 小红的图上加边

n, m = map(int, input().split())  # 读取 n 和 m 的值
wt = list(map(int, input().split()))  # 读取所有物品的权重
fa = list(range(n))  # 初始化并查集，每个元素的根节点初始化为自己

def findset(x):
    """找到 x 的根节点，并进行路径压缩"""
    if fa[x] != x:
        fa[x] = findset(fa[x])  # 路径压缩
    return fa[x]

for _ in range(m):
    u, v = map(int, input().split())
    u -= 1  # 将输入的索引调整为从0开始
    v -= 1
    fau = findset(u)
    fav = findset(v)
    if fau != fav:
        fa[fau] = fav  # 合并两个集合
        wt[fav] = max(wt[fau], wt[fav])  # 更新根节点的权重

wts = [wt[i] for i in range(n) if findset(i) == i]  # 收集所有根节点的权重
wts.sort()  # 对权重进行排序
print(sum(wts[1:]))  # 输出除最小权重外所有权重的总和

F 小红的括号串

import math

mod = 10**9 + 7
n = int(input())  # 读取整数 n，表示字符串 s 的长度
s = input()  # 读取字符串 s

def balanced_substrings(s, n):
    """
    计算具有相同数量左右括号的子串的数量。
    
    参数:
    s (str): 输入的括号字符串。
    n (int): 字符串的长度。
    
    返回:
    int: 满足条件的子串的数量。
    """
    if n % 2 == 1:  # 如果 n 为奇数，不可能平衡
        return 0
    
    n //= 2
    a = s.count('(')  # 统计左括号的数量
    b = s.count(')')  # 统计右括号的数量
    
    if a > n or b > n:  # 如果任一括号的数量超过了 n/2，则不可能平衡
        return 0
    
    # 使用组合数公式计算可行的放置方式，并取模
    return math.comb(2 * n - a - b, n - a) % mod

print(balanced_substrings(s, n))  # 输出结果