Es ist nicht besonders schwierig, wenn Sie sich in der richtigen Reihenfolge entscheiden, während Sie i von i = N verringern.
N = int(input())
a = list(map(int, input().split()))
t = [0] * N
for i in range(N - 1, -1, -1):
t[i] = (sum(t[2 * (i + 1) - 1::i + 1]) % 2) ^ a[i]
print(sum(t))
print(*[i + 1 for i in range(N) if t[i] == 1])
Auf den ersten Blick sieht es so aus, als wäre die Imos-Methode eine Aufnahme, aber da es S -0,5 gibt, beträgt die Anzahl aufeinanderfolgender Aufnahmen auf demselben Kanal nur 0,5, wenn Sie die Imos-Methode verwenden, ohne über irgendetwas nachzudenken.
Die einfachste Lösung besteht darin, die imos-Methode zu beenden. Wenn "= 1" anstelle von "+ = 1", ist es in Ordnung, zu verdoppeln, und tatsächlich ist es in Bezug auf die Verarbeitungszeit in Ordnung.
N, C = map(int, input().split())
tt = [[0] * (10 ** 5 + 1) for _ in range(C)]
for _ in range(N):
s, t, c = map(int, input().split())
for i in range(s - 1, t):
tt[c - 1][i] = 1
ct = [0] * (10 ** 5 + 1)
for i in range(C):
for j in range(10 ** 5 + 1):
ct[j] += tt[i][j]
print(max(ct))
Es ist nicht schwierig, mit der imos-Methode zu arbeiten, aber es ist überraschend schwierig, elegant zu schreiben. Ist es am einfachsten, die Bewegung zu sortieren und zu ändern, wenn sie kontinuierlich ist?
from operator import itemgetter
N, C = map(int, input().split())
stc = [list(map(int, input().split())) for _ in range(N)]
stc.sort(key=itemgetter(2, 0))
cs = [0] * (10 ** 5 + 1)
pt, pc = -1, -1
for s, t, c in stc:
if pt == s and pc == c:
cs[s] += 1
else:
cs[s - 1] += 1
cs[t] -= 1
pt, pc = t, c
for i in range(1, 10 ** 5 + 1):
cs[i] += cs[i - 1]
print(max(cs))
Übrigens kann es theoretisch Moos sein, aber wenn ich durch den Kanal ging, dass es nicht so stark traf, wurde ich fest geschnappt. Fragesteller, wie erwartet …….
"f (A, B)" ist dasselbe wie "f (0, A-1) x oder f (0, B)", also "g (N) = f (0, N)", wobei "g" ist Schreiben Sie es einfach. Sie können die Zahl 1 für jede Ziffer der Binärzahl zählen und als gerade oder ungerade verarbeiten.
def h(A, n):
if A == -1:
return 0
return A // (2 * n) * n + max(A % (2 * n) - (n - 1), 0)
def g(A):
result = 0
for i in range(48):
t = 1 << i
if h(A, t) % 2 == 1:
result += t
return result
def f(A, B):
return g(A - 1) ^ g(B)
A, B = map(int, input().split())
print(f(A, B))
Tatsächlich ist für jedes gerade "n" "n xor (n + 1)" "1", so dass Sie nicht für jede Ziffer zählen müssen.
def g(A):
t = ((A + 1) // 2) % 2 #Für jede gerade n n^ (n + 1) == 1
if A % 2 == 0:
return A ^ t
return t
def f(A, B):
return g(A - 1) ^ g(B)
A, B = map(int, input().split())
print(f(A, B))
Addieren Sie für jedes Bit von A die Anzahl der stehenden und nicht stehenden Bits. Wenn die Anzahl der stehenden Bits größer ist, ist das Bit 0, und wenn die Anzahl der nicht stehenden Bits größer ist, beträgt das Bit 1 X. Alles was Sie tun müssen ist. Da X jedoch eine Bedingung von K oder weniger hat und K überschreitet, werde ich es aufgeben, ein wenig einzustellen.
N, K = map(int, input().split())
A = list(map(int, input().split()))
bcs = [0] * 41
for i in range(N):
a = A[i]
for j in range(41):
if a & (1 << j) != 0:
bcs[j] += 1
X = 0
for i in range(40, -1, -1):
if bcs[i] >= N - bcs[i]:
continue
t = 1 << i
if X + t <= K:
X += t
result = 0
for i in range(N):
result += X ^ A[i]
print(result)
ABC094D - Binomial Coefficients
a i </ sub> ist die maximale Anzahl. A j </ sub> ist die nächstgrößere Zahl, aber a i </ sub> </ sub> C < sub> a j </ sub> </ sub> == a i </ sub> </ sub> C a i </ sub> -a j </ sub> </ sub> und suchen Sie nach der Reihenfolge.
n = int(input())
a = list(map(int, input().split()))
a.sort()
x = a[-1]
b = [(min(e, x - e), e) for e in a[:-1]]
b.sort()
print(x, b[-1][1])
Die Addition ist eine monotone Zunahme, aber XOR ist keine monotone Zunahme, da 1 x oder 1 0 ist. Übrigens, da 0 x oder N == 0 + N "XOR <= Addition". Mit anderen Worten, das Ergebnis von XOR ist auch nur einmal geringer als das Ergebnis der Addition. Unabhängig davon, wie stark Sie die Anzahl von r von dort aus erhöhen, wird es nicht für immer gleich sein. Wenn ein bestimmtes l <r den gleichen Wert hat, hat auch die Kombination von l + 1 und r den gleichen Wert. Sie können sehen, dass die Toshakutori-Methode gut ist.
N = int(input())
A = list(map(int, input().split()))
result = 0
r = 0
xs = A[0]
cs = A[0]
for l in range(N):
while r < N - 1 and xs ^ A[r + 1] == cs + A[r + 1]:
r += 1
xs ^= A[r]
cs += A[r]
result += r - l + 1
xs ^= A[l]
cs -= A[l]
print(result)
Recommended Posts