Trouvez la distance du sommet 1 pour tous les sommets de la recherche et affichez 0 pour les distances paires et 1 pour les distances impaires.
N = int(input())
link = [[] for _ in range(N)]
for _ in range(N - 1):
u, v, w = map(int, input().split())
link[u - 1].append((v - 1, w))
link[v - 1].append((u - 1, w))
d = [-1] * N
d[0] = 0
q = [0]
while q:
p = q.pop()
for n, w in link[p]:
if d[n] == -1:
d[n] = d[p] + w
q.append(n)
for i in d:
print(i % 2)
"A X i </ sub> </ sub> + A Y i </ sub> </ sub> + Z i </ sub> est pair "." Signifie que si vous connaissez un A, vous connaissez l'autre. Si "A X </ sub> + A Y </ sub> + Z i </ "sub> est un nombre pair." Et "A X </ sub> + A Z </ sub> + Z j </ sub> est un nombre pair." Si vous connaissez l'un des A, vous connaissez les deux autres.
Ensuite, la question est de savoir combien de groupes de A n'ont aucune relation les uns avec les autres, et cela peut être réduit au problème du comptage du nombre de groupes avec Union Find.
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())
parent = [-1] * N
for _ in range(M):
X, Y, Z = map(int, input().split())
unite(parent, X - 1, Y - 1)
print(len([x for x in parent if x < 0]))
Il suffit de marcher et de se téléporter dans l'ordre, et de visiter celui dont la fatigue augmente le moins.
N, A, B = map(int, input().split())
X = list(map(int, input().split()))
result = 0
for i in range(N - 1):
result += min(A * (X[i + 1] - X[i]), B)
print(result)
Pour tous les nombres sauf -1 et 1, nous ajoutons simplement le pouvoir magique nécessaire pour le changer en 1, mais il y a des cas où il faut moins de puissance magique pour passer par un autre nombre que pour le changer directement en 1. , Trouvez la puissance magique minimale pour changer chaque nombre à 1 par la méthode Worshall Floyd.
def warshall_floyd(n, d):
for i in range(n):
for j in range(n):
for k in range(n):
d[j][k] = min(d[j][k], d[j][i] + d[i][k])
H, W = map(int, input().split())
N = 10
d = [None] * N
for i in range(N):
d[i] = list(map(int, input().split()))
warshall_floyd(N, d)
m = [d[i][1] for i in range(N)]
result = 0
for _ in range(H):
for i in map(int, input().split()):
if i == -1:
continue
result += m[i]
print(result)
Seule l'épée avec le maximum de dégâts peut être balancée. Aucune épée avec moins de dégâts que ces dégâts de balancement n'est requise. Si les dégâts dépassent H avant d'atteindre le maximum de dégâts à balancer Il n'y a pas besoin de secouer. S'il n'y en a pas assez, secouez autant. Si l'épée tremblante est dans l'épée de lancer, si vous la lancez après l'avoir secouée, le nombre de fois sera le même, donc il n'y a pas de problème.
N, H = map(int, input().split())
a, b = zip(*(map(int, input().split()) for _ in range(N)))
a_max = max(a) #Dégâts maximum de secousse
b = [x for x in b if x > a_max] #Retirez une épée dont les dégâts de lancer sont inférieurs aux dégâts maximum du balancement car il est inutile de la lancer
b.sort(reverse=True)
result = 0
#Lancez les épées par ordre décroissant de dégâts, et si vous pouvez les vaincre avant que l'épée ne s'épuise, c'est tout.
for x in b:
result += 1
H -= x
if H <= 0:
break
#Si vous ne pouvez pas le vaincre simplement en le jetant, balancez l'épée avec le maximum de dégâts
#Si l'épée avec le maximum de dégâts au swing est dans l'épée à lancer, cela signifie que l'épée a été lancée après avoir balancé autant que nécessaire.
if H > 0:
result += (H + (a_max - 1)) // a_max
print(result)
Recommended Posts