Modèle AtCoder ABC 179 Python (A ~ E)

Résumé

Seuls A et B ont été résolus. Les performances ont diminué récemment.

problème

https://atcoder.jp/contests/abc179

A. Plural Form

Répondre

S = input()

if S[-1] == 's':
    answer = S + 'es'
else:
    answer = S + 's'

print(answer)

Écrivez en fonction de l'énoncé du problème.

B. Go to Jail

Répondre

N = int(input())
D = [tuple(map(int, input().split())) for _ in range(N)]

answer = 'No'

count = 0
for i in range(N):
    if D[i][0] != D[i][1]:
        count = 0
    else:
        count += 1
    
    if count == 3:
        answer = 'Yes'
        break

print(answer)

Il détermine l'alignement et renvoie Oui lorsque` `` compte atteint `` 3```.

C. A x B + C

Répondre

N = int(input())

answer = 0
for a in range(1, N):
    answer += (N-1) // a

print(answer)

Compte tenu des restrictions, il semble que la boucle for ne puisse être activée qu'une seule fois. a * b + c = nTransformera * b = n - cPuisa * b On peut appeler cela le problème du comptage du nombre de combinaisons de.

D. Leaping Tak

Répondre

MOD = 998244353
N, K = map(int, input().split()) #N est le nombre de carrés, K est le nombre de sections(K est égal ou inférieur à 10)
kukan = [tuple(map(int, input().split())) for _ in range(K)]

dp = [0] * (N+1)
dp[1] = 1

sumdp = [0] * (N+1)
sumdp[1] = 1

for i in range(2, N+1):
    for l, r in kukan:
        li = max(i - l, 0)
        ri = max(i - r - 1, 0)

        dp[i] += sumdp[li] - sumdp[ri]
        dp[i] %= MOD

    sumdp[i] = sumdp[i-1] + dp[i]

print(dp[N])

Normalement, prendre dp n'est pas dans le temps, alors utilisez `` dp et la somme cumulée sumdp```.

E. Sequence Sum

Répondre

N, X, M = map(int, input().split())
count_memo = [-1] * 10**6 #Nombre de notes
num_memo = [0] #Une note. 1 index. 

a = X
count = 1
count_memo[a] = count
num_memo.append(a)
for i in range(1, N):
    a = a**2 % M
    if count_memo[a] == -1:
        count += 1
        count_memo[a] = count
        num_memo.append(a)
    else:
        break

if count == N: #Total si terminé avant d'entrer dans le cycle
    answer = sum(num_memo)
else:
    #Nombre et total jusqu'à l'entrée dans le cycle
    count_before_cycle = count_memo[a] - 1
    sum_before_cycle = sum(num_memo[:count_before_cycle+1])
    #Nombre et total de 1 cycle
    count_cycle = count - count_before_cycle
    sum_cycle = sum(num_memo[count_before_cycle+1:])
    #Nombre et total des cycles restants
    cycle_count = (N - count) // count_cycle
    sum_after_cycle = sum_cycle * cycle_count
    #Trop et total
    remain_count =  (N - count) % count_cycle
    sum_remain = sum(num_memo[count_before_cycle+1:count_before_cycle+1 + remain_count])

    answer = sum_before_cycle + sum_cycle + sum_after_cycle + sum_remain

print(answer)

aEntre dans le cycle quelque part. Donc,

1. Avant d'entrer dans le cycle
2. Cycle
3. Répéter le cycle
4. Nombre supplémentaire de fois se terminant au milieu du cycle Divisez en 4 façons et ajoutez-les ensemble.