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.
Étant donné deux types de chaînes de caractères et le nombre de boules appartenant à chacune, il est difficile de retirer l'une des boules spécifiées puis de sortir chaque nombre.
Le fait est que l'entrée ʻU` est spécifiée pour correspondre à l'une ou l'autre des chaînes.
S, T = input().split()
A, B = map(int, input().split())
U = input()
if U == S: A -= 1
else: B -= 1
print(A, B)
C'est un problème pour remplacer la chaîne de caractères spécifiée par «x» et la sortir.
Renvoie x pour le nombre de caractères saisis.
S = input()
print("x" * len(S))
Le problème est de vérifier le tableau d'entrée pour les doublons.
J'ai vérifié la longueur du tableau sans duplication en le mettant dans le type d'ensemble. Notez que la sortie est «OUI» au lieu de «Oui» (une perte).
N = int(input())
A = list(input().split())
if len(set(A)) == N:
print('YES')
else:
print('NO')
C'est un problème de répondre à la valeur attendue en extrayant K dés avec des nombres adjacents des dés dont la valeur maximale est $ p_i $.
Les valeurs attendues sont des valeurs indépendantes pour chaque dé, donc l'addition et la soustraction sont possibles. Tout d'abord, trouvez la valeur attendue de chacun et écrasez la valeur maximale de chaque dé.
Après cela, j'ai recherché la valeur maximale tout en décalant l'index (en diminuant la valeur qui sort en décalant et en augmentant la valeur ajoutée).
N, K = map(int, input().split())
P = list(map(int, input().split()))
P = [(1+p)/2 for p in P]
tmp = sum(P[:K])
maxV = tmp
for i in range(N-K):
tmp += P[i+K] - P[i]
maxV = max(maxV, tmp)
print(maxV)
La question est de répondre au nombre de nombres à N chiffres pouvant contenir K nombres de 1 à 9 en notation décimale.
Le nombre qui satisfait les nombres de 1 à N chiffres 999 ...
J'ai vu le commentaire. Il semble utiliser un algorithme appelé digit DP. J'ai appris le chiffre DP en me référant à ici.
Créez un tableau en trois dimensions comme celui-ci.
dp[i][smaller][k]
Ici, ʻiest le nombre de chiffres comptés avec l'extrémité gauche comme 1 (pensez qu'il y a un autre 0ème chiffre avec une valeur de 0 sur la gauche), etplus petit` est la valeur maximale que les chiffres jusqu'à cela peuvent prendre s'il est 1. Non, «k» représente le nombre de nombres différents de zéro qui sont apparus jusqu'à ce chiffre.
Le code ci-dessous compte à partir de la gauche selon ces règles. Une explication détaillée du processus est délicate, je vais donc l'omettre.
Je suis passé par là.
N = [0] + list(map(int, input()))
N = [0] + list(map(int, input()))
K = int(input())
n = len(N)
DP = [
[[0] * (K+2) for _ in range(2)] for _ in range(n)
]
#0ème chiffre(0)Prend la valeur maximale avec k=Il y a un élément de 0.
DP[0][0][0] = 1
for i in range(1, n):
for k in range(K+1):
if N[i] != 0:
DP[i][0][k+1] += DP[i-1][0][k]
DP[i][1][k] += DP[i-1][0][k]
DP[i][1][k+1] += DP[i-1][0][k] * (N[i] - 1)
else:
DP[i][0][k] += DP[i-1][0][k]
DP[i][1][k] += DP[i-1][1][k]
DP[i][1][k+1] += DP[i-1][1][k] * 9
print(DP[n-1][1][K] + DP[n-1][0][K])
C'est tout pour cet article.
Recommended Posts