Concours AtCoder Débutant 173

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 </ sub>, a 2 </ sub>, ..., a N </ sub> , A 1 </ sub> + a 2 </ sub> + a 2 </ sub> + a 3 </ sub> + a 3 </ sub> + ... 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 </ sup>).

Recommended Posts

Concours AtCoder Débutant 177
Concours AtCoder Débutant 179
Concours AtCoder Débutant 172
Concours AtCoder Débutant 180
Concours AtCoder Débutant 173
Concours Atcoder Débutant 153
Critique du concours AtCoder Beginner Contest 152
Critique du concours AtCoder Débutant 160
Critique du concours AtCoder Débutant 178
Concours AtCoder Débutant 180 Remarque
Critique du concours AtCoder pour débutant 166
Concours AtCoder Débutant 182 Remarque
Critique du concours AtCoder
Critique du concours AtCoder Débutant 181
AtCoder Débutant Contest 171 Critique
Critique du concours AtCoder pour débutant 182
Critique du concours AtCoder pour débutant 177
AtCoder Débutant Contest 168 Critique
Critique du concours AtCoder
Concours AtCoder pour débutants 167
Critique du concours AtCoder pour débutant 172
Concours AtCoder Débutant 183 Remarque
Critique du concours AtCoder
Concours AtCoder Débutant 184 Remarque
AtCoder Débutant Contest 175 Critique
Critique du concours AtCoder
Critique du concours AtCoder Beginner Contest 153
Critique du concours AtCoder pour débutant 156
AtCoder Débutant Contest 161 Critique
AtCoder Débutant Contest 170 Critique
Critique du concours AtCoder
AtCoder Débutant Contest 173 Critique
AtCoder Débutant Contest 155 Critique
AtCoder Débutant Contest 162 Évaluation
AtCoder Beginner Contest 181 Rapport de participation
AtCoder Beginner Contest 175 Inscription virtuelle
AtCoder Beginner Contest 161 Rapport de participation
AtCoder Débutant Contest 176 Rapport de participation
AtCoder Beginner Contest 154 Rapport de participation
Note de participation au concours pour débutants AtCoder # 003
AtCoder Beginner Contest 166 Rapport de participation
AtCoder Beginner Contest 153 Rapport de participation
AtCoder Beginner Contest 145 Rapport de participation
AtCoder Débutant Contest 184 Rapport de participation
Rapport de participation au concours AtCoder Débutant 160
AtCoder Beginner Contest 169 Rapport de participation
AtCoder Beginner Contest 178 Rapport de participation
AtCoder Beginner Contest 163 Rapport de participation
AtCoder Beginner Contest 159 Rapport de participation
AtCoder Beginner Contest 164 Rapport de participation
AtCoder Beginner Contest 168 Rapport de participation
Rapport de participation au concours AtCoder Débutant 150
AtCoder Beginner Contest 158 Rapport de participation
Rapport de participation au concours AtCoder Débutant 180
AtCoder Beginner Contest 156 Rapport de participation
AtCoder Beginner Contest 162 Rapport de participation
AtCoder Débutant Contest 157 Rapport de participation
AtCoder Beginner Contest 167 Rapport de participation