牛客周赛 Round 51

算法·Python - 随笔分类 - Chiaki17 - 博客园 (cnblogs.com)https://www.cnblogs.com/Chiaki17/category/2410756.html

A 小红的同余

def find_modular_inverse(m):
    # 使用 pow 函数来找到 2 在模 m 下的逆元
    x = pow(2, -1, m)
    return x

# 从标准输入读取 m 的值
m = int(input().strip())
# 调用函数并输出结果
print(find_modular_inverse(m))

B 小红的三倍数

def is_multiple_of_three(numbers):
    # 初始化总和
    total_sum = 0
    # 遍历每个数字
    for number in numbers:
        # 将数字转换为字符串并计算各位数字的和
        total_sum += sum(int(digit) for digit in number)
    
    # 检查总和是否是3的倍数
    if total_sum % 3 == 0:
        return "YES"
    else:
        return "NO"

# 从标准输入读取数据
n = int(input().strip())  # 读取数字个数
numbers = input().strip().split()  # 读取数字，这些数字已经是字符串形式

# 输出结果
print(is_multiple_of_three(numbers))

C 小红充电

# 输入六个整数x, y, t, a, b, c
x, y, t, a, b, c = map(int, input().split())

# 如果x小于等于t，直接计算从x到100需要的时间
if x <= t:
    print((100 - x) / c)
# 否则，计算两种可能路径的最小时间：
# 1. 直接从x到100
# 2. 先从x到t，再从t到100
else:
    time_direct = (100 - x) / b  # 直接从x到100的时间
    time_via_t = (x - t) / y + (100 - t) / c  # 先从x到t，再从t到100的总时间
    print(min(time_direct, time_via_t))

D 小红的 gcd 

import math

# 读取输入数据
a = input()  # 输入大整数，以字符串形式表示
b = int(input())  # 输入除数

m = 0  # 初始化余数
# 遍历字符串中的每一个字符，将其转换为整数，并计算余数
for i in a:
    m = m * 10 + int(i)  # 更新整数值
    m = m % b            # 实时计算余数，避免溢出

# 计算并输出最大公约数
print(math.gcd(m, b))  # 输出余数m和除数b的最大公约数

E 小红走矩阵

import heapq

# 读取矩阵的大小
n = int(input())
mat = []

# 读取矩阵数据
for _ in range(n):
    mat.append(list(map(int, input().split())))

# 方向数组，表示可以向右、向下、向左、向上移动
directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]

# 初始化优先队列，起始点为(0,0)，起始成本为矩阵第一个元素
queue = [(mat[0][0], 0, 0)]

# 访问集合，记录已经访问过的节点
visited = {(0, 0)}

# 开始优先队列的循环处理
while queue:
    cost, i, j = heapq.heappop(queue)  # 弹出当前路径最大值最小的状态
    
    # 如果到达右下角，则输出当前的cost并结束程序
    if i == n - 1 and j == n - 1:
        print(cost)
        break

    # 遍历四个可能的移动方向
    for dx, dy in directions:
        nx, ny = i + dx, j + dy
        # 确保新位置在矩阵范围内，并且未被访问过
        if 0 <= nx < n and 0 <= ny < n and (nx, ny) not in visited:
            # 将新位置加入队列，并更新路径的最大值
            heapq.heappush(queue, (max(cost, mat[nx][ny]), nx, ny))
            # 标记新位置为已访问
            visited.add((nx, ny))

F 小红的数组

pypy3

from sys import stdin
from bisect import bisect_left

input = lambda: stdin.readline().rstrip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lii = lambda: list(mii())

# 读取数组长度
n = ii()
# 读取数组元素
nums = lii()
# 构建前缀和数组
pres = [0] * (n + 1)
for i, x in enumerate(nums):
    pres[i + 1] = pres[i] + x

# 读取查询数量
nq = ii()
# 存储查询
queries = [[] for _ in range(n + 1)]
for idx in range(nq):
    left, right = mii()
    # 存储左边界减一以及查询的索引
    queries[right].append((left - 1, idx))

# 单调栈，用于存储前缀和的索引
stk1 = []
stk2 = []
# 存储答案的数组
ans = [0] * nq

# 遍历前缀和数组
for right, x in enumerate(pres):
    # 保持stk1单调递减
    while stk1 and pres[stk1[-1]] < x:
        stk1.pop()
    # 保持stk2单调递增
    while stk2 and pres[stk2[-1]] > x:
        stk2.pop()
    # 将当前索引压入栈
    stk1.append(right)
    stk2.append(right)
    # 处理以当前右边界的所有查询
    for left, idx in queries[right]:
        # 找到第一个不小于left的索引
        mx = stk1[bisect_left(stk1, left)]
        mn = stk2[bisect_left(stk2, left)]
        # 计算答案
        ans[idx] = pres[mx] - pres[mn]

# 输出所有答案
print(*ans, sep='\n')