Si vous faites exactement le même mouvement que TopCoDeer, le score sera de 0 point, donc le score maximum sera de 0 point ou plus. Pour le moment, j'ai décidé de faire exactement le même mouvement que TopCoDeer, et donné le nombre de pars et de goo. Si vous comptez le nombre de fois et passez du dernier goo au pair autant de fois que vous remplissez les conditions, vous obtiendrez le score le plus élevé.
s = input()
print(max((s.count('g') * 2 - len(s)) // 2, 0))
Si 1 et 2 peuvent être échangés, et 2 et 3 peuvent être échangés, alors 1 et 3 peuvent également être échangés. Autrement dit, s'ils sont dans la même union, ils peuvent être échangés. Mais je n'ai jamais entendu dire qu'il y a des moments où le tri des bulles n'est pas possible, donc ce n'est probablement pas grave. Intuitivement, vous devriez les trier dans l'ordre à partir de la fin. Vérifiez s'il y a un i dans l'union, et la somme des nombres est la réponse.
from sys import setrecursionlimit
def find(parent, i):
t = parent[i]
if t < 0:
return i
t = find(parent, t)
parent[i] = t
return t
def unite(parent, i, j):
i = find(parent, i)
j = find(parent, j)
if i == j:
return
parent[j] += parent[i]
parent[i] = j
setrecursionlimit(10 ** 5)
N, M = map(int, input().split())
p = list(map(int, input().split()))
parent = [-1] * N
for _ in range(M):
x, y = map(int, input().split())
unite(parent, x - 1, y - 1)
result = 0
for i in range(N):
if find(parent, i) == find(parent, p[i] - 1):
result += 1
print(result)
Si vous vérifiez si la majorité de toutes les sous-chaînes sont du même caractère, ce sera * O * (* N * 2 </ sup>), donc TLE est inévitable. Au fait, si la majorité est le même caractère, c'est la même chose. Le même caractère apparaît avec deux caractères consécutifs ou un espace entre eux. Cela peut être vu immédiatement en créant un caractère avec la même majorité. * O * (* N *) peut être utilisé pour vérifier si cela existe. Vous pouvez le vérifier pour pouvoir le résoudre.
s = input()
for i in range(len(s) - 1):
if s[i] == s[i + 1]:
print(*[i + 1, i + 2])
exit()
for i in range(len(s) - 2):
if s[i] == s[i + 2]:
print(*[i + 1, i + 3])
exit()
print(*[-1, -1])
Si vous l'écrivez en naïf, * O * (* N * 3 </ sup>), même s'il est assoupli par la somme cumulée, c'est * O * (* N * 2 </ sup>) et que faire avec TLE. ? Premièrement, au lieu de compter "la somme est un multiple de M", comptez "la somme des restes divisée par M est 0". Puis A 1 </ sub>, A 1 </ sub> + A 2 </ sub>, ..., A 1 </ sub> + A 2 </ sub> ... A N Comptez le nombre de </ sub> divisé par M. Si t m </ sub> est le nombre d'occurrences du reste m, le nombre à compter lorsque l = 1, r = 1..N Est t 0 </ sub>. Ensuite, l = 2, r = 1..N doit être compté, mais le nombre de A 1 </ sub> divisé par M est réduit de chacun. Donc, je pense un instant que t A 1 </ sub>% M </ sub>, mais comme l = 1 et r = 1 n'étaient que A 1 </ sub>, ce Doit être omis, qui est t A 1 </ sub>% M </ sub> -1 et celui-ci doit être omis même lors du calcul après l = 3. Ne le faites pas. Ensuite, passez à l = N pour la réponse.
N, M = map(int, input().split())
A = list(map(int, input().split()))
t = {}
c = 0
for a in A:
c += a
c %= M
if c in t:
t[c] += 1
else:
t[c] = 1
result = 0
if 0 in t:
result += t[0]
c = 0
for a in A:
c += a
c %= M
t[c] -= 1
result += t[c]
print(result)
Puisque nous recherchons le plus petit dans l'ordre lexical, nous voulons insérer '(' à gauche autant que possible et ')' à droite autant que possible. Donc '(' est à l'extrême gauche et ')' est Supposons que vous insériez uniquement à l'extrémité droite. Je me demande combien seront insérés après cela, mais comme la longueur de la chaîne de caractères est au maximum de 100, elle ne deviendra pas TLE même si elle est réellement transformée. Lors de l'effacement des parenthèses associées Ajoutez simplement des parenthèses sur le bord gauche ou droit jusqu'à ce que la chaîne soit vide.
N = int(input())
S = input()
result = S
while True:
while True:
t = S.replace('()', '')
if t == S:
break
S = t
if S == '':
break
elif S[0] == ')':
S = '(' + S
result = '(' + result
elif S[0] == '(':
S = S + ')'
result = result + ')'
print(result)
Le score maximum est de trouver l'itinéraire le plus court de (1, 1) à (H, W) dans la recherche de priorité de largeur et de changer toutes les cellules blanches qui n'ont pas passé sur l'itinéraire le plus court en noir. La réponse est le nombre de cellules blanches. - Le nombre de carrés sur l'itinéraire le plus court.
H, W = map(int, input().split())
s = [input() for _ in range(H)]
dp = [[2501] * W for _ in range(H)]
dp[0][0] = 1
q = [(0, 0)]
while q:
nq = []
while q:
y, x = q.pop()
t = dp[y][x] + 1
if y < H - 1:
if s[y + 1][x] == '.' and dp[y + 1][x] > t:
dp[y + 1][x] = t
nq.append((y + 1, x))
if y > 0:
if s[y - 1][x] == '.' and dp[y - 1][x] > t:
dp[y - 1][x] = t
nq.append((y - 1, x))
if x < W - 1:
if s[y][x + 1] == '.' and dp[y][x + 1] > t:
dp[y][x + 1] = t
nq.append((y, x + 1))
if x > 0:
if s[y][x - 1] == '.' and dp[y][x - 1] > t:
dp[y][x - 1] = t
nq.append((y, x - 1))
q = nq
if dp[H - 1][W - 1] == 2501:
print(-1)
else:
print(sum(s[y].count('.') for y in range(H)) - dp[H - 1][W - 1])
Recommended Posts