[PYTHON] AtCoder Beginner Contest 149 Teilnahmebericht

AtCoder Beginner Contest 149 Teilnahmebericht

ABC149A - Strings

Brechen Sie in 1 Minute durch. Schreiben Sie einfach

S, T = input().split()

print(T + S)

ABC149B - Greedy Takahashi

Brechen Sie in 6 Minuten durch. Schreiben Sie einfach. Zuerst verstand ich die Bedeutung des Satzes nicht, also dachte ich, ich würde in beiden Fällen K-Blätter reduzieren, aber ich versuchte das Eingabe- / Ausgabebeispiel und erkannte die richtige Bedeutung.

A, B, K = map(int, input().split())

a = max(A - K, 0)
K -= A - a
b = max(B - K, 0)
print(*[a, b])

ABC149C - Next Prime

Brechen Sie in 7 Minuten durch. Bringen Sie einfach das Eratostenes-Sieb mit, das in ABC084D --2017-ähnlicher Nummer geschrieben ist, und schreiben Sie es.

from math import sqrt

N = 10 ** 6

p = [True] * (N + 1)
p[0] = False
p[1] = False
n = int(sqrt(N) + 1)
for j in range(4, N + 1, 2):
  p[j] = False
for i in range(3, n + 1, 2):
  if p[i]:
    for j in range(i + i, N + 1, i):
      p[j] = False


X = int(input())
for i in range(X, N + 1):
    if p[i]:
        print(i)
        break

ABC149D - Prediction and Restriction

Durchbruch in 44 Minuten. WA1. Gehen wir davon aus, dass wir den Zug vorerst gewinnen werden, und wenn wir ihn so implementieren, dass WA herauskommt und wir DP müssen, wenn wir den gleichen Zug wie den K-Zug erhalten. Aber ist es nicht die Anzahl der Menschen, die durchbrechen (schlechte Argumentation)? “Ich war lange besorgt und erkannte, dass es besser sein könnte, zu verlieren. AC. Aus diesem Grund lag die Rangliste im 14. Jahrhundert. Ich fühlte mich gerettet, weil ich keine Bewertung hatte.

N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

d = {'r': P, 's': R, 'p': S}
result = 0
wins = [False] * K
for i in range(len(T)):
    if not wins[i % K] or T[i] != T[i - K]:
        result += d[T[i]]
        wins[i % K] = True
    else:
        wins[i % K] = False
print(result)

ABC149E - Handshake

Ich konnte nicht durchbrechen. Ich konnte mir keine Möglichkeit vorstellen, die Bestellung abzuwerten, und endete mit dem vollen TLE.

Nachtrag: Es ist unmöglich, alle Kombinationen zu generieren, da der Berechnungsbetrag * O * (10 10 </ sup>) beträgt. Selbst wenn Sie versuchen, die generierten Kombinationen auf M zu halten, M steckt auch bei 10 10 </ sup> fest. Kehren Sie also die Idee um und finden Sie die Glücksschwelle, die auftritt, sobald die Anzahl der Kombinationen M überschreitet. Dies ist die kumulative Summe. Sie kann mit * O * ( N </ i> log N </ i>) berechnet werden.

Sobald dies gefunden ist, drehen Sie die Schleife basierend auf der linken Hand, wissen Sie, wie weit die rechte Hand von der zuvor erstellten kumulativen Summe abgesenkt werden kann, und erstellen Sie eine weitere kumulative Summe der Potenz der rechten Hand * O * (* N *) Da die Anzahl der Kombinationen jedoch nicht genau M ist, ist es notwendig, die Schwelle des Glücks, die zu einem Zeitpunkt auftritt, so weit zu subtrahieren, wie sie M überschreitet. ..

N, M = map(int, input().split())
A = list(map(int, input().split()))

A.sort(reverse=True)
LB = A[-1] * 2  #Die untere Grenze des Glücks, die durch einen Handschlag angehoben werden kann, liegt darin, dass Sie die Person mit der geringsten Kraft sowohl in der linken als auch in der rechten Hand halten.
UB = A[0] * 2   #Die Obergrenze des Glücks, die durch einen Handschlag erhöht werden kann, liegt darin, dass Sie die Person mit der höchsten Kraft sowohl in der linken als auch in der rechten Hand halten.

# cgs[i]Ist die Anzahl der Gäste mit Power i oder höher
cgs = [0] * (UB + 1)
for a in A:
    cgs[a] += 1
for i in range(UB, 0, -1):
    cgs[i - 1] += cgs[i]


#Dichotomisieren Sie die Glücksschwelle, die auftritt, sobald die Anzahl der Kombinationen M oder mehr beträgt
def is_ok(n):
    m = 0
    for a in A:
        m += cgs[max(n - a, 0)]
    return m >= M


ok = LB
ng = UB + 1
while ng - ok > 1:
    m = (ok + ng) // 2
    if is_ok(m):
        ok = m
    else:
        ng = m

# cps[i]Ist ein[0]~A[i]Kumulative Summe von
cps = A[:]
for i in range(1, N):
    cps[i] += cps[i - 1]

result = 0
for a in A:
    t = cgs[max(ok - a, 0)]
    if t != 0:
        result += a * t + cps[t - 1]
        M -= t
result += ok * M
print(result)

Recommended Posts