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.
La chaîne de caractères T est une question pour savoir si la chaîne de caractères S a un caractère à la fin.
Nous avons comparé en découpant T avec T [: -1].
S = input()
T = input()
if S == T[:-1]:
print('Yes')
else:
print('No')
Il y a $ A $ pour les cartes étiquetées 1, $ B $ pour les cartes étiquetées 0 et $ C $ pour les cartes étiquetées -1. La valeur maximale lors du choix de $ K $ est une question à répondre.
La priorité doit être donnée au comptage dans l'ordre de 1, 0, -1. Cependant, comme il s'agit de $ A, B, C \ leq2 \ times10 ^ 9 $, cela fera mal si vous essayez de le mettre dans un tableau ou de le tourner avec for. (Une perte)
A, B, C, K = map(int, input().split())
out = min(A, K) - max(0, K-A-B)
print(out)
Le problème est de trouver le prix le plus bas dans une combinaison où tous les éléments additionnés pour chaque nombre dépassent $ X $.
La limite de $ N, M \ leq 12 $ permet une couverture complète. Des calculs parallèles ont été effectués en utilisant ʻitertools.product () puis numpy` pour la recherche complète.
import itertools
import numpy as np
N, M, X = map(int, input().split())
items = np.array([list(map(int, input().split())) for _ in range(N)], dtype=np.int32)
out = 10**18
for c in itertools.product([False, True], repeat=N):
tmp = np.sum(items[np.where(c)], axis=0)
if M == np.count_nonzero(tmp[1:] >= X):
out = min(out, tmp[0])
if out == 10**18:
print(-1)
else:
print(out)
Chaque ville a une destination de chaîne. La question est de se téléporter K fois depuis la première ville et de répondre à la ville qui arrive.
Si vous recherchez correctement à partir de la limite de $ K \ leq10 ^ {18} $, c'est TLE. J'ai abandonné. Voir les réponses des autres.
Il faut noter que la plage de K est $ K \ leq 10 ^ {18} $, mais la plage de N est $ N \ leq 2 \ times 10 ^ {5} $. En d'autres termes, cette recherche est toujours en boucle.
Commencez par rechercher normalement. Enregistrez le temps «t_zero» qui est arrivé pour la première fois dans chaque ville sous forme de tableau, et calculez le temps d'un tour lorsque vous atteignez la même ville une deuxième fois. Prenez le terme restant du temps d'un tour de K. Réutilisez les calculs précédemment effectués sans avoir à rechercher à nouveau le temps restant k. J'ai passé le code suivant.
N, K = map(int, input().split())
A = list(map(int, input().split()))
t_zero = [-1] * N
t = 0
a = 1
while t_zero[a-1] == -1:
if t == K:
break
t_zero[a-1] = t
t += 1
a = A[a-1]
else:
k = (K - t_zero[a-1]) % (t - t_zero[a-1])
a = t_zero.index(t_zero[a-1] + k) + 1
print(a)
Le codage couleur des blocs disposés en ligne horizontale pose un problème. Cependant, la même couleur peut être autorisée l'une à côté de l'autre jusqu'à K, et combien de combinaisons y a-t-il?
Il y a $ M \ times (M-1) ^ {N-1} $ combinaisons dans lesquelles N morceaux de M couleur sont disposés de manière à ne pas être côte à côte.
Lorsque les blocs de groupe K peuvent être côte à côte, on peut dire que les blocs $ N-K $ sont disposés de telle sorte que les couleurs ne s'alignent pas. De plus, la façon de sélectionner la combinaison de blocs adjacents est $ _ {N-1} C _ {K} $ pièces.
En d'autres termes, vous pouvez calculer la formule suivante.
Ce qui suit est mis en œuvre. Cependant, pendant la production, je n'ai pas pu bien accélérer le calcul et je n'ai pas pu le résoudre à temps.
N, M, K = map(int, input().split())
out = 0
mod = 998244353
c = 1
for k in range(K+1):
out += M * pow(M-1, N-k-1, mod) * c
out %= mod
c *= (N-k-1) * pow(k+1, mod-2, mod)
c %= mod
print(out)
ici
C'est tout pour cet article.
Recommended Posts