Ceci est un article de synthèse pour les débutants des professionnels de la compétition.
La solution que j'écris ici est écrite en regardant les commentaires et les soumissions d'autres personnes. Ce n'est peut-être pas ce que vous avez réellement soumis.
Oh, ** L'avez-vous fait dimanche? ** **
Je ne connaissais pas l'existence du concours. Je n'ai pas vu l'horaire. C'est pourquoi je résous le problème après la fin du concours.
Atcoder semble organiser un concours tous les samedis. La prochaine fois, je demanderai si ABC ou ARC aura lieu.
Si l'entrée est «ABC», la sortie «ARC». Sinon, affichez "ABC".
S = input()
if S == 'ABC':
print('ARC')
else:
print('ABC')
Chacun des K types de bonbons sera distribué aux enfants avec le numéro $ \ boldsymbol {A_k} $. La question est de savoir combien d'enfants n'ont pas reçu les bonbons.
Je pense que vous devriez combiner les éléments de chaque arrangement, supprimer la duplication, vérifier le "nombre de personnes qui ont reçu des bonbons", et soustraire du nombre total de personnes.
N, K = map(int, input().split())
A = []
for _ in range(K):
d = input()
A += list(map(int, input().split()))
print(N - len(set(A)))
↓ est un modèle que j'ai essayé de pousser dans le type d'ensemble à chaque fois. Celui-ci était plus rapide.
N, K = map(int, input().split())
A = set()
for _ in range(K):
d = input()
A = A.union(set(map(int, input().split())))
print(N - len(A))
La question est de savoir combien d'observatoires remplissent la condition «plus haut que tous les observatoires adjacents à vous».
Cela ressemble à un problème de graphique ... mais vous n'avez pas à y penser si dur. Faux si l'observatoire adjacent est plus grand que vous. Vrai si vous n'en avez pas. Enfin, j'ai vérifié le nombre de True et l'ai sorti.
Notez que les deux observatoires de «même hauteur» sont faux.
N, M = map(int, input().split())
H = list(map(int, input().split()))
good = [True] * N
for _ in range(M):
A, B = map(int, input().split())
A -= 1
B -= 1
if H[A] >= H[B]:
good[B] = False
if H[A] <= H[B]:
good[A] = False
print(sum(good))
C'est un problème de sortir un ensemble d'entiers (A, B) qui satisfait.
De combien les plages $ A et B $ doivent-elles atteindre la limite $ X \ leq 10 ^ 9 $? Quel est le nombre qui dépasse 10 $ ^ 9 $ à la cinquième puissance?
n = 1
while n**5 < 10**9:
n += 1
print(n)
# 64
Je vais essayer de fouiller toute la zone en prenant environ deux fois cette plage.
import itertools
X = int(input())
for a, b in itertools.product(range(128), range(-128, 128)):
if(a ** 5 - b ** 5 == X):
print(a, b)
break
Je suis passé par.
Quand j'ai vu le commentaire,
Il semble correct de penser à rechercher $ n $ qui satisfait, c'est-à-dire jusqu'à $ n = 120 $. Le résultat est correct, mais réfléchissons-y correctement. Après cela, tant que ce calcul réussit, il est également judicieux de rechercher une plage aussi large que possible.
E - This Message Will Self-Destruct in 5s
"Ce message disparaît automatiquement après 5 secondes."
La question est de répondre au nombre qui satisfait $ A_i + A_j = j-i $.
ʻItertools.combinations_with_replacement () `couvre tout. C'est devenu TLE.
import itertools
N = int(input())
A = list(map(int, input().split()))
count = sum([j-i == A[i-1]+A[j-1] for i, j in itertools.combinations_with_replacement(range(1, N+1), 2)])
print(count)
Je ne sais pas et abandonne. Voir le commentaire. Est-il possible d'échapper à $ O (n ^ 2) $?
C'est fait. Il vous suffit de calculer un statut indépendant pour chaque valeur.
Pour la valeur $ A_i $, calculez la valeur $ L_i = i + A_i $, $ R_i = i --A_i $. Vous pouvez calculer le nombre de combinaisons où $ L_i = R_j $ en comptant le nombre de valeurs contenues respectivement dans $ R $ et $ L $.
C'est pourquoi je l'ai implémenté avec le code suivant.
import collections
N = int(input())
A = list(map(int, input().split()))
L = [i + A[i] for i in range(N)]
R = [i - A[i] for i in range(N)]
countL = collections.Counter(L)
countR = collections.Counter(R)
print(sum([countL[n] * countR[n] for n in countL.keys()]))
C'est tout pour cet article.
Recommended Posts