Concours AtCoder Débutant 173

J'ai dormi juste avant, j'avais sommeil, j'étais somnolent.Peut-être à cause de cela, j'ai été en retard pour résoudre les problèmes A et B, et j'ai également donné un WA impuissant. Alors Yoshi!

ABC173A - Payment

Percer en deux minutes et demie. Il suffit d'écrire.

N = int(input())

if N % 1000 == 0:
    print(0)
else:
    print(1000 - N % 1000)

ABC173B - Judge Status Summary

Percer en 4 minutes. Il suffit d'écrire.

N = int(input())
S = [input() for _ in range(N)]

d = {'AC': 0, 'WA': 0, 'TLE': 0, 'RE': 0}
for s in S:
    d[s] += 1
print('AC x', d['AC'])
print('WA x', d['WA'])
print('TLE x', d['TLE'])
print('RE x', d['RE'])

ABC173C - H and V

Percer en 6 minutes et demie. En regardant les contraintes, c'est une recherche un peu complète en un coup d'œil. Récemment, il y a beaucoup de recherches peu complètes?

from itertools import product

H, W, K = map(int, input().split())
c = [input() for _ in range(H)]

result = 0
for a in product([True, False], repeat=H):
    for b in product([True, False], repeat=W):
        t = 0
        for y in range(H):
            if a[y]:
                continue
            for x in range(W):
                if b[x]:
                    continue
                if c[y][x] == '#':
                    t += 1
        if t == K:
            result += 1
print(result)

ABC173D - Chat in a Circle

Percer en 14 minutes. WA1. N -1 à N. de toute façon. Je ne pourrais pas m'empêcher d'essayer ne serait-ce qu'un échantillon.

Si vous essayez à la main, si A est trié par ordre décroissant comme _{1 , a _{2 , ..., a _{N , A _{1 + a _{2 + a _{2 + a _{3 + a _{3 + ... Je savais que ça allait être, alors je l'ai soumis et AC.}}}}}}}}

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

A.sort(reverse=True)
result = 0
for i in range(N - 1):
    result += A[(i + 1) // 2]
print(result)

ABC173E - Multiplication 4

Pénétration en 41 minutes WA1. La route positive a été mal identifiée.

Tout d'abord, regardez le nombre et déterminez s'il sera positif, 0 ou négatif. S'il est positif, la valeur absolue sera grande, et si elle est négative, la valeur absolue sera petite. Bien. Notez que s'il est positif, vous ne pouvez utiliser que deux valeurs négatives.

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

m = 1000000007

a = [e for e in A if e > 0]
b = [e for e in A if e < 0]
c = [e for e in A if e == 0]
#Plus itinéraire
if len(a) >= K - (min(K, len(b)) // 2) * 2:
    a.sort(reverse=True)
    b.sort()
    result = 1
    i = 0
    j = 0
    k = 0
    while k < K:
        if k < K - 1 and i < len(a) - 1 and j < len(b) - 1:
            x = a[i] * a[i + 1]
            y = b[j] * b[j + 1]
            if y >= x:
                result *= y
                result %= m
                j += 2
                k += 2
            else:
                result *= a[i]
                result %= m
                i += 1
                k += 1
        elif k < K - 1 and j < len(b) - 1:
            y = b[j] * b[j + 1]
            result *= y
            result %= m
            j += 2
            k += 2
        elif i < len(a):
            result *= a[i]
            result %= m
            i += 1
            k += 1
        elif j < len(b):
            result *= b[j]
            result %= m
            j += 1
            k += 1
    print(result)
#0 itinéraire
elif len(c) != 0:
    print(0)
#Route moins
else:
    a.sort()
    b.sort(reverse=True)
    result = 1
    i = 0
    j = 0
    k = 0
    while k < K:
        if i < len(a) and j < len(b):
            if a[i] <= -b[i]:
                result *= a[i]
                result %= m
                i += 1
                k += 1
            else:
                result *= b[j]
                result %= m
                j += 1
                k += 1
        elif i < len(a):
            result *= a[i]
            result %= m
            i += 1
            k += 1
        elif j < len(b):
            result *= b[j]
            result %= m
            j += 1
            k += 1
    print(result)

ABC173F - Intervals on Tree

Je ne pouvais pas le résoudre, je ne pouvais penser qu'à une solution pour * O * (* N * ^{2 ).}