牛客周赛 Round 54

A 清楚姐姐的糖葫芦

print(input().count('o'))

B 清楚姐姐买竹鼠

# 读取三个整数值
a, b, x = map(int, input().split())

# 计算并打印最小成本
# cost_by_a: 只使用方案A的成本
# cost_by_b: 使用方案B，每3个为一组的成本
# mixed_cost: 结合方案A和B的成本，即剩余不足3个的使用方案A，其余使用方案B
cost_by_a = a * x
cost_by_b = ((x + 2) // 3) * b
mixed_cost = (x % 3) * a + (x // 3) * b
print(min(cost_by_a, cost_by_b, mixed_cost))

C 竹鼠饲养物语

import sys
input = sys.stdin.read
data = input().split()

n, m = map(int, data[:2])  # 读取 n 和 m 的值
numbers = list(map(int, data[2:]))  # 读取接下来 m 个数字作为序列

from collections import Counter
frequency_dict = Counter(numbers)  # 统计每个数字出现的频率

current_index = 1
minimum_count = 10**9  # 初始化为一个非常大的数字
result = 0

# 遍历每个可能的数字，并更新序列中连续的最小频率
while current_index in frequency_dict:
    minimum_count = min(minimum_count, frequency_dict[current_index])
    result += minimum_count
    current_index += 1

print(result)  # 输出最终的结果

D 清楚姐姐跳格子

from collections import deque, defaultdict

# 读取输入数据
n = int(input())
nums = list(map(int, input().split()))

# 使用字典来存储每个位置的因子
factors = defaultdict(list)
for index in range(1, n + 1):
    for divisor in range(1, nums[index - 1] + 1):
        if divisor > 1000:
            break
        if nums[index - 1] % divisor == 0:
            factors[index].append(divisor)

# 初始化队列和距离数组
queue = deque([1])
distances = [0] * (n + 10)

# 广度优先搜索 (BFS) 遍历
while queue:
    found = False
    current = queue.popleft()
    for step in factors[current]:
        next_pos = current + step
        prev_pos = current - step
        # 检查向前移动的合法性
        if 1 <= next_pos <= n and distances[next_pos] == 0:
            distances[next_pos] = distances[current] + 1
            queue.append(next_pos)
        # 检查向后移动的合法性
        if 1 <= prev_pos <= n and distances[prev_pos] == 0:
            distances[prev_pos] = distances[current] + 1
            queue.append(prev_pos)
        # 检查是否到达了最后位置
        if next_pos == n:
            found = True
            break
    if found:
        break

# 输出到达最后位置的最小步数
print(distances[n])

E 清楚姐姐的布告规划

# 设置一个很大的数，用来表示无法到达的情况
NO_PATH = 10**5

# 定义一个函数，用于找到覆盖给定长度需要的最少跳跃次数
def find_minimum_jumps(length, max_leaps) -> int:
    # 初始化一个数组，用来记录到达每个位置的最少跳跃次数，初始设为无法到达
    min_jumps = [NO_PATH] * (length + 1)
    # 起始位置的跳跃次数为0，因为已经在起点上
    min_jumps[0] = 0
    # 遍历每个位置，计算到达该位置的最少跳跃次数
    for i in range(1, length + 1):
        # 当前位置可以跳的最远距离
        current_leap = max_leaps[i - 1]
        # 从当前位置向前检查，寻找最优跳跃路径
        for j in range(i, 0, -1):
            # 如果当前位置向前的距离超出了最大跳跃距离，停止检查
            if i - j + 1 > current_leap:
                break
            # 如果当前位置的最大跳跃范围内无法到达终点或之前的位置无法到达，则跳过当前计算
            if length + 1 - j < current_leap or min_jumps[j - 1] == NO_PATH:
                continue
            # 计算跳到当前位置后的最小跳数，并更新最小跳跃数组
            min_jumps[j - 1 + current_leap] = min(min_jumps[j - 1 + current_leap], min_jumps[j - 1] + 1)
    # 如果最终位置的跳跃次数仍然是无法到达，返回-1，否则返回所需的最小跳跃次数
    return min_jumps[length] if min_jumps[length] != NO_PATH else -1

# 输入测试用例的数量
test_cases = int(input())

# 对于每一个测试用例，读取数据并调用函数计算结果
for _ in range(test_cases):
    length = int(input())  # 输入整个序列的长度
    max_leaps = list(map(int, input().split()))  # 输入每个位置的最大跳跃长度
    print(find_minimum_jumps(length, max_leaps))  # 输出最小跳跃次数

F 竹鼠，宝藏与故事