Atcoder ABC166 A-E en Python

C'était à nouveau complet. E est le commentaire AC. Comme le code du concours est affiché tel quel, il peut y avoir des parties disgracieuses, mais pardonnez-moi s'il vous plaît.

A. A?C Renvoie ARC si l'entrée est ABC, ABC sinon

ABC166a.py

s=input()

if s=="ABC":
    print("ARC")
else:
    print("ABC")

B. Trick or Treat Pour tous les bonbons, ajoutez +1 à l'index de l'enfant que vous avez. Enfin, comptez et sortez les enfants qui n'ont pas de bonbons.

ABC166b.py

n,k=map(int,input().split())
d=[]
a=[]
for i in range(k):
    d.append(int(input()))
    a.append(list(map(int,input().split())))
    
aa=[0]*n

for j in a:
    for k in j:
        aa[k-1]+=1 #Index de l'enfant qui a des bonbons+1
        
ans=0

for x in aa:
    if x==0:
        ans+=1 #Le nombre d'enfants qui n'ont pas de bonbons est de 0, alors comptez le nombre d'enfants.

print(ans)

C. Peaks Préparez un tableau de la même longueur que le nombre de sommets, comparez les hauteurs des deux sommets et ajoutez +1 au sommet inférieur. Si les hauteurs sont identiques, les deux sont incrémentées de +1. Enfin, le nombre de sommets dont la valeur est 0 est affiché. À propos, une route ne signifiait que la route menant au sommet, pas celle qui pouvait être atteinte d'un seul coup. J'ai mal compris et j'ai perdu du temps.

ABC166c.py

import copy

n,m=map(int,input().split())
h=list(map(int,input().split()))
l=[]
for i in range(m):
    a,b=map(int,input().split())
    l.append([a,b])
    
ll=[0]*n

for j in l:
    if h[j[0]-1]>h[j[1]-1]:
        ll[j[1]-1]+=1
    elif h[j[0]-1]==h[j[1]-1]:
        ll[j[1]-1]+=1
        ll[j[0]-1]+=1
    else:
        ll[j[0]-1]+=1

ans=0
#print(ll)
for k in ll:
    if k==0:
        ans+=1
print(ans)

D. I hate factorization Puisqu'il n'y a aucune restriction sur $ A $ ou $ B $, le tournoi à la ronde ne devient pas TLE: j'ai préparé environ 1000 pièces et calculé. Commentaire officiel En y regardant, il semble qu'environ 250 nombres négatifs sont suffisants. Il est nécessaire de prendre abs une fois car la racine de puissance d'un nombre négatif n'est pas sortie correctement.

ABC166d.py

x=int(input())
l=[]

for i in range(300): #300**5=X inférieur à 2430000000000^Nombre pouvant être représenté par 5 (-x inclus) ajouté
    a=i**5
    l.append(a)
    l.append(-a)
        
for j in l:
    for k in l:
        aa=j-k
        if j!=k and aa==x:
            ans=[]
            for z in [j,k]:
                aaa=abs(z)**(1/5) #5ème racine
                if z>=0:
                    ans.append(int(aaa))
                else:
                    ans.append(int(-aaa))
            print(*ans)                
            exit()

E. This Message Will Self-Destruct in 5s Voir Explication officielle pour l'approche. Préparez la somme de la valeur d'index et de la hauteur et la différence entre la valeur d'index et la hauteur. Puis comptez le nombre de motifs où les deux valeurs correspondent. Spécifiquement, deux tableaux l et r sont préparés, et le nombre de r ayant la même valeur pour chaque élément de l est compté. Quand j'ai utilisé count, il est devenu TLE, j'ai donc utilisé Counter pour le stocker sous forme de tableau associatif et je l'ai récupéré. Je n'ai pas vérifié à quelle vitesse il est ...

ABC166e_TLE.py

from collections import Counter

n=int(input())
a=list(map(int,input().split()))
ans=0
l=[]
r=[]
for i,j in enumerate(a):
    l.append(i+j)
    r.append(i-j)

for i in l:
    ans+=r.count(i)
    
print(ans)

ABC166e.py

from collections import Counter

n=int(input())
a=list(map(int,input().split()))
ans=0
l=[]
r=[]
for i,j in enumerate(a):
    l.append(i+j)
    r.append(i-j)

b=Counter(r)
for i in l:
    ans+=b.get(i,0)

print(ans)

Si vous ne pouvez pas résoudre D en 30 à 40 minutes environ, la route vers le bleu clair ne sera pas ouverte. Je dois faire de mon mieux