AtCoder ABC 174 Python

Résumé

Seuls A et B étaient AC. Il semble que C et D seront bientôt résolus, mais c'est difficile à résoudre.

problème

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

A. Air Conditioner

Répondre

X = int(input())

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

Écrivez simplement ceci.

B. Distance

Répondre

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)

Ceci est également juste écrit selon l'énoncé du problème, mais il semble préférable de comparer les carrés des distances que de juger par l'itinéraire.

C. Repsept

Réponse (au moment du concours)

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)

Bien sûr, si vous l'implémentez conformément à l'énoncé du problème, cela ne passera pas. `` 999983 '' dans l'exemple d'entrée 3 est la valeur maximale du problème, mais si vous essayez de résoudre ce problème, vous devez calculer 10 à la puissance 999983, ce qui est évidemment impossible.

Réponse (à une date ultérieure)

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)

Pensez à réduire la puissance de 10.

Le problème est que vous n'avez pas besoin de garder 7 777 777 .... '' car il vous suffit de connaître le premier nombre qui est divisible par le nombre 7 777 777 .... ''. Si vous le gardez, il sera résolu.

En d'autres termes, vous pouvez voir que vous devez répéter `mod = (mod * 10 + 7)% K``` K fois au lieu de target + = 7 * 10 ** i```.

À ce stade, tout ce que vous avez à faire est d'écrire.

D. Alter Altar

Réponse (au moment du concours)

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)

Cela ne peut pas être résolu. J'ai réfléchi trop fort et la branche conditionnelle a été foirée. Selon cette politique, il n'y a pas assez de branches conditionnelles.

Réponse (à une date ultérieure)

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)

Plus tard, j'ai découvert qu'elle fondait simplement quand j'y pensais avec un esprit propre.

wr Tout ce que vous avez à faire est d'éliminer la gamme, donc à la fin, toutrVous pouvez voir que vous devez opérer de manière à ce qu'ils soient rassemblés sur le côté gauche.

Le nombre d'opérations dans lesquelles tous les R '' sont rassemblés sur le côté gauche peut être trouvé en expérimentant ce qui suit. --De total_count_R```, qui est le nombre de tous R`` --Subtract left_count_R, qui est le nombre de `` `` R contenu de gauche à `` total_count_R```

Une fois que vous savez cela, le code peut être écrit assez simplement.

E. Logs

Réponse (au moment du concours)

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)

Cela ne passera pas. La politique est de "continuer à couper la plus longue bûche en deux", mais avec cela, par exemple, si vous coupez la même bûche deux fois, vous devez la couper en trois parties égales, mais coupez à moitié Ce sera envers vous.

Vous pouvez également l'améliorer un peu et "trouver la bûche la plus longue et la couper à nouveau avec la meilleure méthode de coupe", mais cela semble difficile à mettre en œuvre, et probablement TLE J'ai abandonné parce que ça le serait.

Réponse (à une date ultérieure)

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)

Pensez à l'envers, «coupez le journal K fois pour le minimiser». "Pouvez-vous le faire en K fois pour que le journal ait une certaine longueur (minimum)?"

Allez chercher "le bon endroit pour minimiser la longueur du journal" dans une recherche de 2 minutes, A ce moment-là, def check () '' `` est utilisé pour juger "si cela peut être fait en K fois".

** Pour le problème E, j'ai fait référence à YouTube de Katsuppa. ** ** https://youtu.be/0jwtdtinPiE