AtCoder ABC 174 Python

Zusammenfassung

Nur A und B waren Wechselstrom. Es scheint, dass C und D bald gelöst werden, aber es ist schwierig zu lösen.

Problem

https://atcoder.jp/contests/abc174/tasks

A. Air Conditioner

Antworten

X = int(input())

if X >= 30:
    print('Yes')
else:
    print('No')

Schreib das einfach.

B. Distance

Antworten

N, D = map(int, input().split())
count = 0
for _ in range(N):
    x, y = map(int, input().split())
    distance = (x ** 2 + y ** 2)**0.5

    if distance <= D:
        count += 1

print(count)

Dies ist auch nur gemäß der Problemstellung geschrieben, aber es scheint besser, die Quadrate der Entfernungen zu vergleichen, als nach der Route zu beurteilen.

C. Repsept

Antwort (zum Zeitpunkt des Wettbewerbs)

K = int(input())
   
answer = -1
target = 0
for i in range(K):
    target += 7 * 10**i
    if target % K == 0:
        answer = i + 1
        print(answer)
        break

print(answer)

Wenn Sie es gemäß der Problemstellung implementieren, wird es natürlich nicht bestanden. `` `999983``` in Eingabebeispiel 3 ist der Maximalwert des Problems, aber wenn Sie versuchen, dies zu lösen, müssen Sie 10 zur 999983-Leistung berechnen, was offensichtlich unmöglich ist.

Antwort (zu einem späteren Zeitpunkt)

K = int(input())
count = 1
mod = 7
answer = -1

for _ in range(K):
    if mod % K == 0:
        answer = count
        break
    count += 1
    mod = (mod * 10 + 7) % K

print(answer)

Reduzieren Sie die Leistung von 10.

Das Problem ist, dass Sie nicht "7.777.777 ..." behalten müssen, weil Sie nur die erste Zahl kennen müssen, die durch die Zahl "7.777.777 ..." teilbar ist. Wenn Sie es behalten, wird es gelöst.

Mit anderen Worten, Sie können sehen, dass Sie `` mod = (mod * 10 + 7)% K``` K-mal anstelle von `target + = 7 * 10 ** i``` wiederholen sollten.

An diesem Punkt müssen Sie nur noch schreiben.

D. Alter Altar

Antwort (zum Zeitpunkt des Wettbewerbs)

N = int(input())
stones = input()
count_R = stones.count('R')

if N == count_R:
    answer = 0
elif N - count_R > count_R:
    answer = count_R
else:
    if 'R' in list(stones)[:N//2]:
        answer = count_R - 1
    else:
        answer = count_R

print(answer)

Dies kann nicht gelöst werden. Ich dachte zu viel nach und der bedingte Zweig war durcheinander. Mit dieser Richtlinie gibt es nicht genügend bedingte Verzweigungen.

Antwort (zu einem späteren Zeitpunkt)

N = int(input())
stones = input()

total_count_R = stones.count('R')
left_count_R = stones[:total_count_R].count('R')

answer = total_count_R - left_count_R

print(answer)

Später stellte ich fest, dass es einfach schmilzt, wenn ich mit klarem Verstand darüber nachdenke.

wr Alles was Sie tun müssen, ist die Aufstellung zu eliminieren, also am Ende allesrSie können sehen, dass Sie so arbeiten sollten, dass sie auf der linken Seite gesammelt sind.

Die Anzahl der Operationen, bei denen alle `R``` auf der linken Seite gesammelt werden, kann durch Experimentieren mit den folgenden ermittelt werden. --Vom total_count_R``` das ist die Nummer aller`` R``` --Subtrahiere `` left_count_R, was die Anzahl von` `` R ist, die von links nach `` total_count_R``` enthalten ist

Sobald Sie dies wissen, kann der Code ziemlich einfach geschrieben werden.

E. Logs

Antwort (zum Zeitpunkt des Wettbewerbs)

import heapq

N, K = map(int, input().split())
K_copy = K
A = list(map(int, input().split()))
A = list(map(lambda x: x*-1, A))
heapq.heapify(A)

while K:
    max1 = heapq.heappop(A)
    max2 = heapq.heappop(A)

    for i in range(2, K_copy+1):
        temp = max1 / i
        if temp > max2:
            heapq.heappush(A, temp)
            heapq.heappush(A, max2)
            K -= 1
            break

print(A)

Dies wird nicht passieren. Die Richtlinie lautet "weiterhin das längste Protokoll in zwei Hälften schneiden". Wenn Sie jedoch beispielsweise dasselbe Protokoll zweimal schneiden, sollten Sie es in drei gleiche Teile schneiden, jedoch zur Hälfte Es wird dir gegenüber sein.

Sie können es auch ein wenig verbessern und "das längste Holz finden und es mit der besten Schneidemethode erneut schneiden", aber dies scheint schwierig zu implementieren zu sein, und vielleicht "TLE" Ich gab auf, weil es sein würde.

Antwort (zu einem späteren Zeitpunkt)

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

def check(l):
    count = 0
    for L in A:
        count += L // l
        if L % l != 0:
            count += 1
        count -= 1
    return count <= K
        
bottom, top = 0, max(A)

while top - bottom > 1:
    mid = (top + bottom) // 2
    if check(mid):
        top = mid
    else:
        bottom = mid

print(top)

Denken Sie umgekehrt: "Schneiden Sie das Protokoll K-mal, um es zu minimieren." "Können Sie es innerhalb von K-mal tun, um das Protokoll auf eine bestimmte Länge (Minimum) zu bringen?"

Suchen Sie in einer 2-minütigen Suche nach "dem richtigen Ort, um die Länge des Protokolls zu minimieren". Zu diesem Zeitpunkt wird `def check ()` verwendet, um zu beurteilen, "ob dies innerhalb von K-mal möglich ist".

** Für das E-Problem habe ich mich auf Katsuppas YouTube bezogen. ** ** ** https://youtu.be/0jwtdtinPiE