Wenn der Rest der Division von a durch b K oder mehr ist, wird bestätigt, dass b K + 1 oder mehr ist. Der Rest der Division durch b ist 0..b-1, und die Anzahl von K oder mehr, die in diesem einen Zyklus erscheint, ist b. --K. Da a N oder weniger ist, ist die Anzahl der Zyklen N / b. Danach ist es notwendig, über den Rest des Zyklus nachzudenken, aber da N bei 1 beginnt, ist der Zyklus 1, 2, ..., Beachten Sie, dass die Reihenfolge b - 1, 0 ist. Das heißt, wenn N% b n ist, dann ist 1, 2, ..., n und die Anzahl von K = 0 und K = 1 gleich.
N, K = map(int, input().split())
result = 0
for b in range(K + 1, N + 1):
result += (N // b) * (b - K) + max(N % b - max(K - 1, 0), 0)
print(result)
Die Anzahl der Schichten des Burgers der Stufe L und die Anzahl der darin enthaltenen Pastetchen sind N ≤ 50, so dass sie leicht berechnet werden können (und die zu berechnende Formel kann leicht abgeleitet werden, ohne die Schleife zu drehen). Danach wiederholt sich, bis X erschöpft ist. Wenn Sie auf einen Burger der Stufe L stoßen und das verbleibende X größer als der Burger der Stufe L ist, reduzieren Sie X um diese Anzahl von Schichten, fügen Sie diese Anzahl von Pastetchen zum Zähler hinzu, und wenn es kleiner ist, Burger der Stufe L -1. Geh einfach rein.
N, X = map(int, input().split())
def f(N, X):
result = 0
if X >= 1:
X -= 1
else:
return result
if X >= 2 ** ((N - 1) + 2) - 3:
X -= 2 ** ((N - 1) + 2) - 3
result += 2 ** ((N - 1) + 1) - 1
else:
return result + f(N - 1, X)
if X >= 1:
X -= 1
result += 1
else:
return result
if X >= 2 ** ((N - 1) + 2) - 3:
X -= 2 ** ((N - 1) + 2) - 3
result += 2 ** ((N - 1) + 1) - 1
else:
return result + f(N - 1, X)
if X >= 1:
X -= 1
else:
return result
return result
print(f(N, X))
Wenn Sie 3 oder mehr duplizierende Karten haben, können Sie 2 Duplikate reduzieren, ohne die Anzahl der Kartentypen zu verringern, unabhängig davon, wie Sie 3 wählen. Wenn Sie 2 Duplikatkarten haben, können Sie 2 Duplikatkarten auf einer Seite kaufen. Eine duplizierende Karte kann die Duplizierung auf 0 reduzieren, ohne die Anzahl der Kartentypen zu verringern. Wenn eine duplizierende Karte vorhanden ist, können zwei duplizierende Karten und eine andere Karte die Anzahl der Kartentypen reduzieren. Kann um 1 reduziert werden, aber die Duplizierung kann auf 0 reduziert werden. Schließlich lautet die Antwort die Anzahl der Kartentypen minus 1, wenn die Anzahl der Duplikate ungerade ist, und 0, wenn sie gerade ist.
N = int(input())
A = list(map(int, input().split()))
t = len(set(A))
if (len(A) - t) % 2 == 0:
print(t)
else:
print(t - 1)
Wenn p i </ sub> = i ist, tauschen Sie einfach mit p i </ sub> und p i + 1 </ sub> und zählen Sie, wie oft Tauschen Sie nur dann mit dem vorherigen p
N = int(input())
p = list(map(int, input().split()))
result = 0
for i in range(N - 1):
if p[i] != i + 1:
continue
result += 1
p[i], p[i + 1] = p[i + 1], p[i]
if p[N - 1] == N:
result += 1
print(result)
Es ist offensichtlich, dass Sie auf jeden Fall ein UnionFind mit einer Größe verwenden, dann einfach nach Jahr sortieren und nacheinander Straßen hinzufügen, um zu sehen, wie viele Städte Menschen kommen und gehen können.
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())
roads = []
for _ in range(M):
a, b, y = map(int, input().split())
roads.append((y, a - 1, b - 1))
Q = int(input())
citizen = []
for i in range(Q):
v, w = map(int, input().split())
citizen.append((w, v - 1, i))
parent = [-1] * N
roads.sort(reverse=True)
results = [None] * Q
t = 0
for c in sorted(citizen, reverse=True):
while t < M and roads[t][0] > c[0]:
unite(parent, find(parent, roads[t][1]), find(parent, roads[t][2]))
t += 1
results[c[2]] = -parent[find(parent, c[1])]
print(*results, sep='\n')
Wenn L = XXXX, beträgt die Anzahl der Paare, die die Bedingung erfüllen, n. Wenn L = 1XXXX, beträgt die Anzahl der Paare, die die Bedingung erfüllen, 0 bis 1111 und die Anzahl der Paare, die die Bedingung erfüllen, und die Anzahl der Paare, die die Bedingung 10000 bis 1XXXX erfüllen. Übrigens, wenn JJJJ + ZZZZ = JJJJ x oder ZZZZ, dann gilt 1JJJJ + ZZZZ = 1JJJ x oder ZZZZ, und JJJJ + 1ZZZZ = JJJJ x oder 1ZZZZ gilt auch. 2 * n.
Die Anzahl der Paare, die die Bedingung erfüllen, wenn L = 1 ist, ist (0,0), (0,1), (1,0), was drei ist. Die Anzahl der Paare, die die Bedingung erfüllen, wenn L = 11 ist, ist wie oben beschrieben. Die Summe von 0 bis 1 = 3 und 10 bis 11 = 2 · 3 ergibt 3 · 3 = 9. In ähnlicher Weise wird L = 111 zu 9 · 3 = 27 und L = 1111 zu 3 4. = 81. Infolgedessen beträgt die Anzahl der Paare, die die Bedingung erfüllen, wenn L = 1XXXX ist, 2 * n + 3 4 </ sup>.
Zu diesem Zeitpunkt können Sie die Antwort jeweils eine Ziffer aus der letzten Ziffer berechnen.
L = input()
result = 1
t = 1
for c in L[::-1]:
if c == '1':
result = result * 2 + t
result %= 1000000007
t *= 3
t %= 1000000007
print(result)
Recommended Posts