input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
#coding:UTF-8
import copy
n = list(map(int,input().split()))
if n[0]<n[1]<n[2]:
print("Yes")
else:
print("No") | #coding:UTF-8
n = list(map(int,input().split()))
if n[0]<n[1]<n[2]:
print("Yes")
else:
print("No") | p02392 |
nums = input().split()
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
if a < b < c:
print('Yes')
else:
print('No') | a, b, c = list(map(int, input().split()))
if a < b < c:
print("Yes")
else:
print("No")
| p02392 |
import sys
if __name__ == '__main__':
import doctest
doctest.testmod()
a, b, c = list(map(int, sys.stdin.read().split()))
if a < b < c:
print("Yes")
else:
print("No")
| #!/usr/bin/env python
#-*- coding: utf-8 -*-
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP1_2_B
if __name__ == '__main__':
a, b, c = list(map(int, input().split()))
if a < b < c:
print("Yes")
else:
print("No")
| p02392 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
mod = 10 ** 9 + 7
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
self.size = [1] * n
self.group_num = n
def root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.root(self.table[x])
return self.table[x]
def get_size(self, x):
r = self.root(x)
return self.size[r]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def union(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
# ランクの取得
s1 = self.table[r1]
s2 = self.table[r2]
if s2 <= s1:
self.table[r2] = r1
self.size[r1] += self.size[r2]
else:
self.table[r1] = r2
self.size[r2] += self.size[r1]
self.group_num -= 1
n = I()
P = LI()
fac = [1] * (n + 1)
inv = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
inv[n] = pow(fac[n], mod-2, mod)
for j in range(n-1, -1, -1):
inv[j] = inv[j+1] * (j+1) % mod
def comb(n, r):
if r > n or n < 0 or r < 0:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
ret = 0
for p in P:
if p == -1:
ret += 1
U = UnionFind(n)
for i in range(n):
if P[i] != -1:
U.union(P[i] - 1, i)
L = []
for j in range(n):
if P[j] == -1:
L += [U.size[j]]
dp = [0] * (len(L) + 1)
dp[0] = 1
for l in range(1, len(L) + 1):
for m in range(l, 0, -1):
dp[m] += dp[m - 1] * L[l - 1]
if L:
dp[1] = sum(L) - len(L)
cycle_cnt = 0
for i in range(1, len(L) + 1):
cycle_cnt = (cycle_cnt + fac[i - 1] * dp[i] * pow(n - 1, len(L) - i, mod)) % mod
ans = (n - (U.group_num - ret)) * pow(n - 1, ret, mod) % mod
print(((ans - cycle_cnt) % mod))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
mod = 10 ** 9 + 7
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
self.size = [1] * n
self.group_num = n
def root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.root(self.table[x])
return self.table[x]
def get_size(self, x):
r = self.root(x)
return self.size[r]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def union(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.size[r1] += self.size[r2]
else:
self.table[r1] = r2
self.size[r2] += self.size[r1]
self.group_num -= 1
n = I()
P = LI()
fac = [1] * (n + 1)
inv = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
inv[n] = pow(fac[n], mod-2, mod)
for j in range(n-1, -1, -1):
inv[j] = inv[j+1] * (j+1) % mod
def comb(n, r):
if r > n or n < 0 or r < 0:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
ret = 0
for p in P:
if p == -1:
ret += 1
U = UnionFind(n)
for i in range(n):
if P[i] != -1:
U.union(P[i] - 1, i)
L = []
for j in range(n):
if P[j] == -1:
L += [U.size[j]]
dp = [0] * (len(L) + 1)
dp[0] = 1
for l in range(1, len(L) + 1):
for m in range(l, 0, -1):
dp[m] += dp[m - 1] * L[l - 1]
if L:
dp[1] = sum(L) - len(L)
cycle_cnt = 0
for i in range(1, len(L) + 1):
cycle_cnt = (cycle_cnt + fac[i - 1] * dp[i] * pow(n - 1, len(L) - i, mod)) % mod
ans = (n - (U.group_num - ret)) * pow(n - 1, ret, mod) % mod
print(((ans - cycle_cnt) % mod))
| p02666 |
def par(a):
L = []
while P[a] != a:
L.append(a)
a = P[a]
for l in L:
P[l] = a
return a
def unite(a, b):
pa = par(a)
pb = par(b)
if pa == pb: return
if LEN[pa] < LEN[pb]:
a, b, pa, pb = b, a, pb, pa
P[pb] = pa
if LEN[pa] == LEN[pb]: LEN[pa] += 1
CNT[pa] += CNT[pb]
def cnt(a):
return CNT[par(a)]
N = int(eval(input()))
P = [i for i in range(N)]
LEN = [1] * N
CNT = [1] * N
FULL = [0] * N
A = [int(a) - 1 for a in input().split()]
for i, a in enumerate(A):
if a < 0: continue
if par(i) != par(a):
unite(i, a)
else:
FULL[i] = 1
for i in range(N):
if FULL[i]:
FULL[par(i)] = 1
X = []
Y = []
for i in range(N):
if par(i) == i:
if FULL[i] == 0:
X.append(CNT[i])
else:
Y.append(CNT[i])
M = len(X)
mod = 10 ** 9 + 7
K = 96
m = int(("1" * 32 + "0" * 64) * 5050, 2)
pa = (1 << 64) - ((1 << 64) % mod)
modP = lambda x: x - ((x & m) >> 64) * pa
ans = (sum(X) + sum(Y) - len(Y)) * pow(N - 1, M, mod) % mod
x = 1
for i, a in enumerate(X):
x *= (a << K) + 1
x = modP(x)
sx = bin(x)[2:] + "_"
L = [int(sx[-(i+1) * K - 1:-i * K - 1], 2) % mod for i in range((len(sx)+K-2) // K)]
fa = 1
ans = (ans + M * pow(N - 1, M - 1, mod)) % mod
for i, l in enumerate(L):
if i == 0: continue
ans = (ans - l * fa * pow(N - 1, M - i, mod)) % mod
fa = fa * i % mod
print(ans) | def par(a):
L = []
while P[a] != a:
L.append(a)
a = P[a]
for l in L:
P[l] = a
return a
def unite(a, b):
pa = par(a)
pb = par(b)
if pa == pb: return
if LEN[pa] < LEN[pb]:
a, b, pa, pb = b, a, pb, pa
P[pb] = pa
if LEN[pa] == LEN[pb]: LEN[pa] += 1
CNT[pa] += CNT[pb]
def cnt(a):
return CNT[par(a)]
N = int(eval(input()))
P = [i for i in range(N)]
LEN = [1] * N
CNT = [1] * N
FULL = [0] * N
A = [int(a) - 1 for a in input().split()]
for i, a in enumerate(A):
if a < 0: continue
if par(i) != par(a):
unite(i, a)
else:
FULL[i] = 1
for i in range(N):
if FULL[i]:
FULL[par(i)] = 1
X = []
Y = []
for i in range(N):
if par(i) == i:
if FULL[i] == 0:
X.append(CNT[i])
else:
Y.append(CNT[i])
M = len(X)
mod = 10 ** 9 + 7
K = 96
m = int(("1" * 32 + "0" * 64) * 5050, 2)
pa = (1 << 64) - ((1 << 64) % mod)
modP = lambda x: x - ((x & m) >> 64) * pa
ans = (sum(X) + sum(Y) - len(Y)) * pow(N - 1, M, mod) % mod
x = 1
for i, a in enumerate(X):
x *= (a << K) + 1
x = modP(x)
sx = bin(x)[2:] + "_"
L = [int(sx[-(i+1) * K - 1:-i * K - 1], 2) % mod for i in range((len(sx)+K-2) // K)]
if M:
fa = 1
ans = (ans + M * pow(N - 1, M - 1, mod)) % mod
for i, l in enumerate(L):
if i == 0: continue
ans = (ans - l * fa * pow(N - 1, M - i, mod)) % mod
fa = fa * i % mod
print(ans) | p02666 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 1000000007 # type: int
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N = int(eval(input()))
P = list(map(int, input().split()))
# 確定している道でグルーピングする
uf = UnionFind(N)
K = 0
undef = [] # 要請未完ノードは記録
for i, p in enumerate(P):
if p != -1:
uf.union(i, p-1)
else:
K += 1
undef.append(i)
# 階乗の事前計算
factorial = [1]*K
for i in range(K-1):
factorial[i+1] = ((i+1)*factorial[i]) % MOD
# 要請が未完のノードが属するグループサイズをメモ
size_undef = []
for u in undef:
size_undef.append(uf.size(u))
# dp[i, j]: i個の根付き木を見てj個を選んだ時の\sum{\prod_v S_v}
# 「メモリ削減したdpとN^2確保するDP、どっちが早いんやろなあ」
dp = [[0]*(K+1) for i in range(K+1)]
dp[0][0] = 1
for i in range(1, K+1):
dp[i][0] = 1
for j in range(i):
dp[i][j+1] += dp[i-1][j]*size_undef[i-1] + dp[i-1][j+1]
# ただしj=1個を選んだ時のものは特別にsize[i]-1を考える必要がある
if K >= 1:
tot = 0
for s in size_undef:
tot += s-1
dp[K][1] = tot
# cycleをカウントする
cycle_count = 0
for i in range(1, K+1):
# i個のグループからなるサイクルがひとつできる
buf = dp[K][i]*factorial[i-1]
buf %= MOD
buf *= pow(N-1, K-i, MOD)
buf %= MOD
cycle_count += buf
# すでに固定サイクルがあれば数える
cycle_count += (uf.group_count()-K)*pow(N-1, K, MOD)
# 求めます
ans = N*pow(N-1, K, MOD) - cycle_count
ans %= MOD
print(ans)
return
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 1000000007 # type: int
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N = int(eval(input()))
P = list(map(int, input().split()))
# 確定している道でグルーピングする
uf = UnionFind(N)
K = 0
for i, p in enumerate(P):
if p != -1:
uf.union(i, p-1)
else:
K += 1
# 階乗の事前計算
factorial = [1]*K
for i in range(K-1):
factorial[i+1] = ((i+1)*factorial[i]) % MOD
# 要請が未完のノードが属するグループサイズをメモ
size_undef = [0]*K
curr = 0
for i, p in enumerate(P):
if p == -1:
size_undef[curr] = uf.size(i)
curr += 1
# dp[i, j]: i個の根付き木を見てj個を選んだ時の\sum{\prod_v S_v}
# 「メモリ削減したdpとN^2確保するDP、どっちが早いんやろなあ」
dp = [0]*(K+1)
dp[0] = 1
dp_new = dp[:]
for i in range(1, K+1):
for j in range(i):
dp_new[j+1] += dp[j]*size_undef[i-1]
dp = dp_new[:]
# ただしj=1個を選んだ時のものは特別にsize[i]-1を考える必要がある
if K >= 1:
tot = 0
for s in size_undef:
tot += s-1
dp[1] = tot
# cycleをカウントする
cycle_count = 0
for i in range(1, K+1):
# i個のグループからなるサイクルがひとつできる
cycle_count += dp[i]*factorial[i-1]*pow(N-1, K-i, MOD)
cycle_count %= MOD
# すでに固定サイクルがあれば数える
cycle_count += (uf.group_count()-K)*pow(N-1, K, MOD)
# 求めます
ans = N*pow(N-1, K, MOD) - cycle_count
ans %= MOD
print(ans)
return
if __name__ == '__main__':
main()
| p02666 |
# AGC002B - Box and Ball
def main():
N, M = tuple(map(int, input().split()))
X = tuple(tuple(map(int, input().split())) for _ in range(M))
R = [0] * (N + 1) # red ball may be in box i
R[1] = 1
C = [1] * (N + 1) # number of balls in box i (count)
for x, y in X:
if R[x]:
R[y] = 1
C[x] -= 1
C[y] += 1
if C[x] == 0:
R[x] = 0
ans = sum(R[1:])
print(ans)
if __name__ == "__main__":
main() | # AGC002B - Box and Ball
import sys
input = sys.stdin.readline
def main():
N, M = tuple(map(int, input().split()))
X = tuple(tuple(map(int, input().split())) for _ in range(M))
R = [0] * (N + 1) # red ball may be in box i
R[1] = 1
C = [1] * (N + 1) # number of balls in box i (count)
for x, y in X:
if R[x]:
R[y] = 1
C[x] -= 1
C[y] += 1
if C[x] == 0:
R[x] = 0
ans = sum(R[1:])
print(ans)
if __name__ == "__main__":
main() | p04034 |
from sys import stdin
def main():
#入力
readline=stdin.readline
N,M=list(map(int,readline().split()))
x=[0]*M
y=[0]*M
for i in range(M):
a,b=list(map(int,readline().split()))
x[i]=a
y[i]=b
li=[[1,0] for _ in range(N+1)]
li[1][1]=1
for i in range(M):
if li[x[i]][0]>=2 and li[x[i]][1]==1:
li[y[i]][0]+=1
li[y[i]][1]=1
li[x[i]][0]-=1
elif li[x[i]][0]==1 and li[x[i]][1]==1:
li[y[i]][0]+=1
li[y[i]][1]=1
li[x[i]][0]-=1
li[x[i]][1]=0
else:
li[y[i]][0]+=1
li[x[i]][0]-=1
count=0
for i in range(1,N+1):
if li[i][1]==1: count+=1
print(count)
if __name__=="__main__":
main() | from sys import stdin
def main():
#入力
readline=stdin.readline
N,M=list(map(int,readline().split()))
x=[0]*M
y=[0]*M
for i in range(M):
x[i],y[i]=list(map(int,readline().split()))
box=[1]*(N+1)
flags=[False]*(N+1)
flags[1]=True
for i in range(M):
out=x[i]
inn=y[i]
if flags[out]==True and box[out]==1:
flags[out]=False
flags[inn]=True
elif flags[out]==True:
flags[inn]=True
box[out]-=1
box[inn]+=1
res=0
for i in range(N+1):
if flags[i]==True:
res+=1
print(res)
if __name__=="__main__":
main() | p04034 |
def main():
n, m = input_list()
box = [False]*n
box[0] = True
nums = [1]*n
for i in range(m):
x, y = input_list()
if box[x-1]:
box[y-1] = True
nums[x-1] = nums[x-1] - 1
nums[y-1] = nums[y-1] + 1
if nums[x-1] == 0:
box[x-1] = False
print((box.count(True)))
def input_list():
return list(map(int, input().split()))
import math
main() | # import sys
# input = sys.stdin.readline
import itertools
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
n, m = input_list()
balls = [1] * n
reds = [False] * n
reds[0] = True
for _ in range(m):
x, y = input_list()
if reds[x-1]:
reds[y-1] = True
balls[x-1] -= 1
balls[y-1] += 1
if balls[x-1] == 0:
reds[x-1] = False
c = 0
for v in reds:
if v:
c += 1
print(c)
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| p04034 |
#!/usr/bin/env python3
(n, m), *q = [[*list(map(int, i.split()))] for i in open(0)]
b = [1] + [0] * (n - 1)
c = [1] * n
for x, y in q:
c[x - 1] -= 1
c[y - 1] += 1
b[y - 1] |= b[x - 1]
b[x - 1] *= c[x - 1] > 0
print((sum(b)))
| (n, m), *q = [[*list(map(int, i.split()))] for i in open(0)]
b = [0] * (n + 1)
b[1] = 1
c = [1] * (n + 1)
for x, y in q:
c[x] -= 1
c[y] += 1
b[y] |= b[x]
b[x] *= c[x] > 0
print((sum(b)))
| p04034 |
n, m = list(map(int, input().split()))
moves = [list(map(int, input().split())) for i in range(m)]
possibilities = [False] * n
possibilities[0] = True
nums = [1] * n
for i in range(m):
x = moves[i][0] - 1
y = moves[i][1] - 1
if possibilities[x]:
possibilities[y] = True
nums[x] -= 1
nums[y] += 1
if nums[x] == 0:
possibilities[x] = False
ans = 0
for j in range(n):
if possibilities[j] and (nums[j] > 0):
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
moves = [list(map(int, input().split())) for i in range(m)]
possibilities = [False] * n
possibilities[0] = True
nums = [1] * n
for i in range(m):
x = moves[i][0] - 1
y = moves[i][1] - 1
if possibilities[x]:
possibilities[y] = True
nums[x] -= 1
nums[y] += 1
if nums[x] == 0:
possibilities[x] = False
print((sum(possibilities)))
| p04034 |
n,m=list(map(int,input().split()))
cnt=[1]*n
s=set([1])
for i in range(m):
x,y=list(map(int,input().split()))
cnt[y-1]+=1
cnt[x-1]-=1
if x in s:
s.add(y)
if cnt[x-1]==0:
if x in s:
s.remove(x)
print((len(s))) | n,m=list(map(int,input().split()))
arr=[list(map(int,input().split())) for _ in range(m)]
count=[1]*(n+1)
s=set()
s.add(1)
for a,b in arr:
count[b]+=1
count[a]-=1
if a in s:
s.add(b)
if count[a]==0:
s.discard(a)
print((len(s))) | p04034 |
n,m=list(map(int,input().split()))
arr=[list(map(int,input().split())) for _ in range(m)]
count=[1]*(n+1)
s=set()
s.add(1)
for a,b in arr:
count[b]+=1
count[a]-=1
if a in s:
s.add(b)
if count[a]==0:
s.discard(a)
print((len(s))) | n,m=list(map(int,input().split()))
arr=[list(map(int,input().split())) for _ in range(m)]
count=[1]*(n+1)
flag=[False]*(n+1)
flag[1]=True
for a,b in arr:
count[b]+=1
count[a]-=1
if flag[a]==True:
flag[b]=True
if count[a]==0:
flag[a]=False
print((flag.count(True))) | p04034 |
n,m=list(map(int,input().split()))
cnt=[1]*n
res=[0]*n
res[0]=1
for i in range(m):
x,y=list(map(int,input().split()))
if res[x-1]==1:
res[y-1]=1
if cnt[x-1]==1:
res[x-1]=0
cnt[x-1]-=1
cnt[y-1]+=1
print((sum(res))) | def main():
n,m=list(map(int,input().split()))
cnt=[1]*n
res=[0]*n
res[0]=1
for i in range(m):
x,y=list(map(int,input().split()))
if res[x-1]==1:
res[y-1]=1
if cnt[x-1]==1:
res[x-1]=0
cnt[x-1]-=1
cnt[y-1]+=1
print((sum(res)))
if __name__=="__main__":
main() | p04034 |
n,m=list(map(int,input().split()))
x=[0]*n
x[0]=1
y=[1]*n
for i in range(m):
a,b=list(map(int,input().split()))
if x[a-1]==1:x[b-1]=1
y[a-1]-=1
y[b-1]+=1
if y[a-1]==0:x[a-1]=0
print((sum(x))) | n,m=list(map(int,input().split()))
ans=[False]*n
ans[0]=True
co=[1]*n
for i in range(m):
x,y=list(map(int,input().split()))
ans[y-1]|=ans[x-1]
co[x-1]-=1
co[y-1]+=1
if co[x-1]==0:ans[x-1]=False
print((ans.count(True))) | p04034 |
N, M = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
red = [0] * (N+1) #赤になりうる場所を１とする
red[1] = 1
red[0] = ""
ball = [1] * (N+1) #個数
ball[0] = ""
for x, y in xy:
ball[y] += 1
ball[x] -= 1
if red[x] == 1:
red[y] = 1
if ball[x] == 0: red[x] = 0
print((red.count(1))) | n,m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
box = [1]*(n+1)
red = [0]*(n+1)
red[1] = 1
for x,y in xy:
box[x] -= 1
box[y] += 1
if red[x] == 1: red[y] = 1
if box[x] == 0: red[x] = 0
print((red.count(1))) | p04034 |
n,m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
box = [1]*(n+1)
red = [0]*(n+1)
red[1] = 1
for x,y in xy:
box[x] -= 1
box[y] += 1
if red[x] == 1: red[y] = 1
if box[x] == 0: red[x] = 0
print((red.count(1))) | n,m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
box = [1]*(n+1)
red = [0]*(n+1)
red[1] = 1
for x,y in xy:
box[x] -= 1
box[y] += 1
if red[x]==1: red[y] = 1
if box[x]==0: red[x] = 0
print((sum(red))) | p04034 |
n,m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
box = [1] * (n+1)
red = [0] * (n+1)
red[1] = 1
for x,y in xy:
box[x] -= 1
box[y] += 1
if red[x] == 1: red[y] = 1
if box[x] == 0: red[x] = 0
print((red.count(1))) | n,m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
red = [0] * (n+1)
red[1] = 1
ball = [1] * (n+1)
for x,y in xy:
ball[x] -= 1
ball[y] += 1
if red[x] == 1:
red[y] = 1
if ball[x] == 0: red[x] = 0
print((sum(red))) | p04034 |
def myAnswer(N:int,M:int,X:list,Y:list) -> int:
red = 0
ans = {0}
box = [1] * N
for x,y in zip(X,Y):
if(x-1 in ans):
ans.add(y-1)
box[x-1] -= 1
box[y-1] += 1
for i in list(ans):
if(box[i] == 0):
ans.remove(i)
return len(ans)
def modelAnswer():
return
def main():
N,M = list(map(int,input().split()))
X = []
Y = []
for _ in range(M):
x,y=list(map(int,input().split()))
X.append(x)
Y.append(y)
print((myAnswer(N,M,X,Y)))
if __name__ == '__main__':
main() | '''
Accepted :No
difficult :
ペナルティ :5分
実際の回答時間 :分
WAの回数 :回
合計時間 :分
'''
def myAnswer(N:int,M:int,X:list,Y:list) -> int:
ans = {0}
box = [1] * N
for x,y in zip(X,Y):
if(x-1 in ans):
if(box[x - 1]==1):
ans.remove(x-1)
ans.add(y-1)
box[x-1] -= 1
box[y-1] += 1
return len(ans)
def modelAnswer():
return
def main():
N,M = list(map(int,input().split()))
X = []
Y = []
for _ in range(M):
x,y=list(map(int,input().split()))
X.append(x)
Y.append(y)
print((myAnswer(N,M,X,Y)))
if __name__ == '__main__':
main() | p04034 |
N, M = list(map(int, input().split()))
b = [1] * N
b[0] = -1
for i in range(M):
x, y = list(map(int, input().split()))
if b[x - 1] < 0:
b[x - 1] += 1
b[y - 1] = -(abs(b[y - 1]) + 1)
else:
b[x - 1] -= 1
if b[y - 1] < 0:
b[y - 1] -= 1
else:
b[y - 1] += 1
print((len([x for x in b if x < 0])))
| N, M = list(map(int, input().split()))
b = [1] * N
b[0] = -1
for i in range(M):
x, y = list(map(int, input().split()))
if b[x - 1] < 0:
b[x - 1] += 1
if b[y - 1] >= 0:
b[y - 1] = -(b[y - 1] + 1)
else:
b[y - 1] -= 1
else:
b[x - 1] -= 1
if b[y - 1] >= 0:
b[y - 1] += 1
else:
b[y - 1] -= 1
print((len([x for x in b if x < 0])))
| p04034 |
n, m = (int(x) for x in input().split())
ab = []
for _ in range(m):
a, b = (int(x) for x in input().split())
ab.append([a-1, b-1])
box = [1]*n
red = [0]*n
red[0] = 1
for x,y in ab:
if 0 < red[x]:
red[y] = 1
box[x] -= 1
box[y] += 1
if box[x] == 0:
red[x] = 0
print((sum(red))) | N,M = list(map(int,input().split()))
XY = [list(map(int,input().split())) for _ in range(M)]
ball_count = [1]*N
red_ball_cand = [0]*N
red_ball_cand[0] = 1
for i in range(M):
x,y = XY[i]
x,y = x-1,y-1
if 0 < red_ball_cand[x]:
red_ball_cand[y] = 1
ball_count[x] -= 1
ball_count[y] += 1
if ball_count[x] == 0:
red_ball_cand[x] = 0
print((sum(red_ball_cand))) | p04034 |
n,m = list(map(int, input().split()))
d = dict()
for i in range(1,n+1):
d[str(i)] = 1
from collections import deque
ans = deque('1')
for _ in range(m):
x,y = input().split()
d[x] -= 1
d[y] += 1
if x in ans and y not in ans:
ans.append(y)
if d[x] == 0 and x in ans:
ans.remove(x)
print((len(ans)))
| n,m = list(map(int, input().split()))
'''
d = dict()
for i in range(1,n+1):
d[str(i)] = 1
from collections import deque
ans = deque('1')'''
box = [1 for i in range(n)]
ans = [0 for i in range(n)]
ans[0] = 1
for _ in range(m):
x,y = list(map(int,input().split()))
box[x-1] -= 1
box[y-1] += 1
if ans[x-1]==1 and ans[y-1]==0:
ans[y-1] = 1
if box[x-1]==0 and ans[x-1]==1:
ans[x-1] = 0
print((sum(ans)))
| p04034 |
N,M = list(map(int,input().split()))
dp = [1 for i in range(N)]
trace = [0 for i in range(N)]
trace[0] = 1
for i in range(M):
x,y = list(map(int,input().split()))
dp[y-1] += 1
dp[x-1] -= 1
if trace[x-1] >= 1:
trace[y-1] = max(trace[y-1]+1,0)
if dp[x-1] == 0:
trace[x-1] = 0
print((len(trace) - trace.count(0)))
| N,M = list(map(int,input().split()))
dp = [1 for i in range(N)]
trace = [0 for i in range(N)]
trace[0] = 1
for i in range(M):
x,y = list(map(int,input().split()))
dp[y-1] += 1
dp[x-1] -= 1
if trace[x-1] >= 1:
trace[y-1] = trace[x-1]
if dp[x-1] == 0:
trace[x-1] = 0
print((len(trace) - trace.count(0))) | p04034 |
N,M = list(map(int, input().split()))
ans = set([0])
cnt = [1] * N
for _ in range(M):
x,y = [int(i) - 1 for i in input().split()]
cnt[x] -= 1
cnt[y] += 1
if x in ans:
if cnt[x] == 0:
ans.remove(x)
ans.add(y)
print((len(ans))) | N,M = list(map(int, input().split()))
ans = set([0])
cnt = [1] * N
for _ in range(M):
x,y = [int(i) - 1 for i in input().split()]
cnt[x] -= 1; cnt[y] += 1
if x in ans:
ans.add(y)
if cnt[x] == 0: # 絶対に赤いボールがyに移される
ans.remove(x)
print((len(ans))) | p04034 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
return
#B
def B():
n,m = LI()
f = [1]*n
l = [0]*n
l[0] = 1
for i in range(m):
x,y = LI()
x -= 1
y -= 1
if l[x]:
l[y] = 1
f[x] -= 1
f[y] += 1
if f[x] == 0:
l[x] = 0
ans = 0
for i in range(n):
if l[i]:
ans += 1
print(ans)
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#Solve
if __name__ == "__main__":
B()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,m = LI()
s = [1]*n
f = [0]*n
f[0] = 1
for _ in range(m):
a,b = LI()
a -= 1
b -= 1
s[a] -= 1
s[b] += 1
if f[a]:
f[b] = 1
if s[a] == 0:
f[a] = 0
print((sum(f)))
return
#Solve
if __name__ == "__main__":
solve()
| p04034 |
N, M = list(map(int, input().split()))
A = [1 for k in range(N)]
B = [0 for k in range(N)]
ans = 0
B[0] = 1
for k in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
if B[x] == 1 and A[x] >= 2:
A[x] -= 1
A[y] += 1
B[y] = 1
elif B[x] == 1 and A[x] == 1:
A[x] -= 1
A[y] += 1
B[x] = 0
B[y] = 1
else:
A[x] -= 1
A[y] += 1
print((B.count(1))) | N, M = list(map(int,input().split()))
B = [list(map(int,input().split())) for k in range(M)]
H = [1]*N
E = [0]*N
E[0] = 1
for e in B:
x, y = e[0]-1, e[1]-1
if E[x] == 1:
if H[x] == 1:
E[x] = 0
E[y] = 1
else:
E[y] = 1
H[x] -= 1
H[y] += 1
print((E.count(1)))
| p04034 |
# coding: utf-8
# Your code here!s = input()
n, m = list(map(int, input().split()))
x = []
y = []
for i in range(m):
xi, yi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
boxes = [False]*n
boxes[0] = True
boxescnt = [1]*n
for i in range(m):
if boxes[x[i]-1] == True:
if boxescnt[x[i]-1] == 1:
boxes[x[i]-1] = False
boxes[y[i]-1] = True
boxescnt[x[i]-1] -= 1
boxescnt[y[i]-1] += 1
print((sum(boxes)))
| n, m = list(map(int, input().split()))
x = []
y = []
for i in range(m):
xi, yi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
num = [1]*n
able = [False]*n
able[0] = True
for i in range(m):
if able[x[i]-1] == True:
able[y[i]-1] = True
num[x[i]-1] -= 1
num[y[i]-1] += 1
if num[x[i]-1] == 0:
able[x[i]-1] = False
print((sum(able))) | p04034 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**8)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,m = li()
ball = [1]*n
inred = [0]*n
inred[0] = 1
for _ in range(m):
x,y = li_()
if inred[x] and ball[x] == 1:
inred[x] = 0
ball[x] = 0
inred[y] = 1
ball[y] += 1
elif inred[x] and ball[x] > 1:
ball[x] -= 1
inred[y] = 1
ball[y] += 1
else:
ball[x] -= 1
ball[y] += 1
ans = 0
for ri in inred:
ans += ri
print(ans)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n, m = li()
balls = [1]*n
canex = [0]*n
canex[0] = 1
for _ in range(m):
x, y = li_()
balls[x] -= 1
balls[y] += 1
if balls[x] > 0 and canex[x]:
canex[y] = 1
elif balls[x] == 0 and canex[x]:
canex[y] = 1
canex[x] = 0
print((sum(canex))) | p04034 |
N,M = list(map(int,input().split()))
R = [0 for _ in range(N+1)]
R[1] = 1
B = [1 for _ in range(N+1)]
B[0] = 0
for _ in range(M):
x,y = list(map(int,input().split()))
if R[x]==1:
R[y] = 1
B[x] -= 1
B[y] += 1
if B[x]==0:
R[x] = 0
print((sum(R))) | N,M = list(map(int,input().split()))
A = [0 for _ in range(N+1)]
B = [1 for _ in range(N+1)]
A[1] = 1
B[0] = 0
for _ in range(M):
x,y = list(map(int,input().split()))
if A[x]==1:
A[y]=1
B[y] += 1
B[x] -= 1
if B[x]==0:
A[x] = 0
print((sum(A))) | p04034 |
N,M = list(map(int,input().split()))
A = [0 for _ in range(N+1)]
B = [1 for _ in range(N+1)]
A[1] = 1
B[0] = 0
for _ in range(M):
x,y = list(map(int,input().split()))
if A[x]==1:
A[y]=1
B[y] += 1
B[x] -= 1
if B[x]==0:
A[x] = 0
print((sum(A))) | N,M = list(map(int,input().split()))
C = {i:[1,0] for i in range(1,N+1)}
C[1] = [1,1]
for _ in range(M):
x,y = list(map(int,input().split()))
C[y][0] += 1
if C[x][1]==1:
C[y][1] = 1
C[x][0] -= 1
if C[x][0]==0:
C[x][1]=0
cnt = 0
for i in range(1,N+1):
if C[i][1]==1:
cnt += 1
print(cnt) | p04034 |
N,M = list(map(int,input().split()))
C = {i:[1,0] for i in range(1,N+1)}
C[1] = [1,1]
for _ in range(M):
x,y = list(map(int,input().split()))
C[y][0] += 1
if C[x][1]==1:
C[y][1] = 1
C[x][0] -= 1
if C[x][0]==0:
C[x][1]=0
cnt = 0
for i in range(1,N+1):
if C[i][1]==1:
cnt += 1
print(cnt) | N,M = list(map(int,input().split()))
C = {i:[1,0] for i in range(1,N+1)}
C[1][1] = 1
for _ in range(M):
x,y = list(map(int,input().split()))
C[x][0] -= 1
C[y][0] += 1
if C[x][1]==1:
C[y][1]=1
if C[x][0]==0:
C[x][1]=0
cnt = 0
for i in range(1,N+1):
cnt += C[i][1]
print(cnt) | p04034 |
N, M = list(map(int,input().split()))
z = [list(map(int,input().split())) for i in range(M)]
box = [[1,1]]
for i in range(N-1):
box.append([0,1])
for i in range(M):
box[z[i][0]-1][1] -= 1
box[z[i][1]-1][1] += 1
if (box[z[i][0]-1][0] == 1):
box[z[i][1]-1][0] = 1
if (box[z[i][0]-1][1] == 0):
box[z[i][0]-1][0] = 0
ans = 0
for i in range(N):
if (box[i][0] != 0):
ans += 1
print(ans) | N, M = list(map(int, input().split()))
Z = [list(map(int,input().split())) for i in range(M)]
kosuu = [1 for _ in range(N)]
red = [False for _ in range(N)]
red[0] = True
for i in range(M):
x = Z[i][0] - 1
y = Z[i][1] - 1
if (kosuu[x] != 0 and red[x] == True):
red[y] = True
if (kosuu[x] == 1 and red[x] == True):
red[x] = False
kosuu[x] -= 1
kosuu[y] += 1
ans = 0
for i in range(N):
if red[i] == True:
ans+=1
print(ans) | p04034 |
n,m = list(map(int,input().split()))
lst = [1]*n
red_lst = [0]
for i in range(m):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
if (x in red_lst) and (y not in red_lst):
red_lst.append(y)
if lst[x]==1 and x in red_lst:
red_lst.remove(x)
lst[x] -= 1
lst[y] += 1
cnt = 0
print((len(red_lst))) | n,m = list(map(int,input().split()))
lst = [1]*n
red_lst = [False]*n
red_lst[0] = True
xx = []
yy = []
for _ in range(m):
a,b = list(map(int,input().split()))
xx.append(a-1)
yy.append(b-1)
for i in range(m):
x,y = xx[i], yy[i]
if red_lst[x]==True and red_lst[y]==False:
red_lst[y]=True
if lst[x]==1 and red_lst[x]:
red_lst[x] = False
lst[x] -= 1
lst[y] += 1
print((red_lst.count(True))) | p04034 |
def solve():
ans = 0
N, M = list(map(int, input().split()))
lis = [1]*N
lis[0] = -1 #赤が入っている可能性があればマイナス
for _ in range(M):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
if lis[x]<0:
lis[y] = -(abs(lis[y])+1)
lis[x] += 1
else:
if lis[y]==0:
lis[y] = 1
else:
lis[y] = (abs(lis[y])+1)*lis[y]//abs(lis[y])
lis[x] -= 1
ans = sum([x<0 for x in lis])
return ans
print((solve())) | def solve():
N, M = list(map(int, input().split()))
lis = [False]*N
cnt = [1]*N
lis[0] = True
for i in range(M):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
if lis[x]==True:
lis[y]=True
if cnt[x]==1:
lis[x]=False
cnt[x] -= 1
cnt[y] += 1
ans = lis.count(True)
return ans
print((solve())) | p04034 |
from collections import defaultdict
n,m=list(map(int, input().split()))
v = [0]*n
v[0]=1
ans = [1]*n
fi = 1
for i in range(m):
a,b=list(map(int, input().split()))
ans[a-1]-=1
ans[b-1]+=1
if v[a-1]:
v[b-1]=1
fi+=1
if ans[a-1]==0:
v[a-1]=0
fi-=1
print((sum(v)))
| n,m=list(map(int, input().split()))
aka = [0]*(n+1)
siroaka = [1]*(n+1)
aka[1] = 1
for i in range(m):
x,y=list(map(int, input().split()))
siroaka[x]-=1
siroaka[y]+=1
if(aka[x]):
aka[y]=1
if(siroaka[x]==0):
aka[x]=0
print((sum(aka)))
| p04034 |
i=lambda:list(map(int,input().split()));n,m=i();l=[0,1]+[0]*n;c=[0]+[1]*n
for _ in[0]*m:x,y=i();l[y]|=l[x];c[y]+=1;c[x]-=1;l[x]=c[x]and l[x]
print((sum(c[i]and l[i]for i in range(n+1)))) | i=lambda:list(map(int,input().split()));n,m=i();a=[0]+[1]*n;b=[0,1]+[0]*n
for _ in[0]*m:x,y=i();a[x]-=1;a[y]+=1;b[y]|=b[x];b[x]&=a[x]>0
print((sum(b))) | p04034 |
n,m=list(map(int,input().split()))
a=[1]*(n+1)
b=[0]*(n+1)
b[1]=1
for _ in range(m):
x,y=list(map(int,input().split()))
a[x]-=1
a[y]+=1
if b[x]:b[y]=1
if a[x]==0:b[x]=0
ans=0
for i,j in zip(a,b):
ans+=(i!=0)*j
print(ans) | n,m=list(map(int,input().split()))
a=[1]*(n+1)
b=[0]*(n+1)
b[1]=1
for _ in range(m):
x,y=list(map(int,input().split()))
a[x]-=1
a[y]+=1
if b[x]:b[y]=1
if a[x]==0:b[x]=0
print((sum(b))) | p04034 |
# coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
N, M = inpl()
move = [inpl() for _ in range(M)]
ans = [0 for _ in range(N)]
ans[0] = 1
box = [1 for _ in range(N)]
# print(ans, box)
for i in range(M):
x, y = move[i]
box[x - 1] -= 1
box[y - 1] += 1
if ans[x - 1]:
ans[y - 1] = 1
if box[x - 1] == 0:
ans[x - 1] = 0
# print(ans, box)
print((sum(ans))) | # coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
N, M = inpl()
# move = [inpl() for _ in range(M)]
ans = [0 for _ in range(N)]
ans[0] = 1
box = [1 for _ in range(N)]
# print(ans, box)
for i in range(M):
# x, y = move[i]
x, y = inpl()
box[x - 1] -= 1
box[y - 1] += 1
if ans[x - 1]:
ans[y - 1] = 1
if box[x - 1] == 0:
ans[x - 1] = 0
# print(ans, box)
print((sum(ans))) | p04034 |
N,M = list(map(int,input().split()))
red_possible = [1] + [0]*(N-1)
balls = [1] * N
for i in range(M):
x,y = [int(x)-1 for x in input().split()]
if red_possible[x]:
red_possible[y] = 1
if balls[x] == 1:
red_possible[x] = 0
balls[x] -= 1
balls[y] += 1
print((sum(red_possible))) | N,M = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(M)]
red = [0] * N
red[0] = 1
ballnum = [1] * N
for a,b in src:
a,b = a-1,b-1
ballnum[b] += 1
ballnum[a] -= 1
if red[a]:
red[b] = 1
if not ballnum[a]:
red[a] = 0
print((sum(red))) | p04034 |
N,M = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for i in range(M)]
rs = [0] * N
rs[0] = 1
cs = [1] * N
for x,y in XY:
x,y = x-1,y-1
if rs[x]:
if cs[x]==1:
rs[x] = 0
rs[y] = 1
cs[x] -= 1
cs[y] += 1
print((sum(rs))) | N,M = list(map(int,input().split()))
XY = [tuple(map(int,input().split())) for i in range(M)]
may_red = [0] * N
may_red[0] = 1
balls = [1] * N
for x,y in XY:
x,y = x-1,y-1
if may_red[x]:
may_red[y] = 1
if balls[x] == 1:
may_red[x] = 0
balls[x] -= 1
balls[y] += 1
print((sum(may_red))) | p04034 |
N, M = list(map(int, input().split()))
y_if = {1}
num = [1] * N
for i in range(M):
x, y = list(map(int, input().split()))
num[x - 1] -= 1
num[y - 1] += 1
if x in y_if:
if num[x - 1] == 0:
y_if.remove(x)
y_if.add(y)
print((len(y_if)))
| N, M = list(map(int, input().split()))
ball = [1] * N
red = {1}
ans = 0
for _ in range(M):
x, y = list(map(int, input().split()))
ball[x - 1] -= 1
ball[y - 1] += 1
if x in red:
red.add(y)
if ball[x - 1] == 0:
red.remove(x)
print((len(red)))
| p04034 |
N, M = list(map(int, input().split()))
boxes = [1] * N
ans = {1}
for i in range(M):
x, y = list(map(int, input().split()))
boxes[x - 1] -= 1
boxes[y - 1] += 1
if x in ans:
if boxes[x - 1] == 0:
ans.remove(x)
ans.add(y)
print((len(ans)))
| def int_(num_str):
return int(num_str) - 1
N, M = list(map(int, input().split()))
balls = [1] * N
red = {0}
for i in range(M):
x, y = list(map(int_, input().split()))
if x in red:
if balls[x] == 1:
red.remove(x)
red.add(y)
else:
red.add(y)
balls[x] -= 1
balls[y] += 1
print((len(red))) | p04034 |
n, m = list(map(int, input().split()))
B = [1] * n
R = [0] * n
R[0] = 1
for _ in range(m):
x, y = list(map(int, input().split()))
x -= 1; y -= 1
if B[x] == 1 and R[x] == 1:
R[x] = 0; R[y] = 1
elif B[x] > 1 and R[x] == 1:
R[y] = 1
B[x] -= 1; B[y] += 1
print((len([i for i in R if i==1]))) | n, m = list(map(int, input().split()))
red = [False] * n
ball = [1] * n
red[0] = True
for _ in range(m):
x, y = [int(x) - 1 for x in input().split()]
if red[x]:
red[y] = True
if ball[x] == 1:
red[x] = False
ball[y] += 1
ball[x] -= 1
print((len(list([x for x in red if x]))))
| p04034 |
N,M = list(map(int,input().split()))
L = list(list(map(int,input().split())) for i in range(M))
A = [1 for i in range(N+1)]
red = [0 for i in range(N+1)]
red[1] = 1
ans = 1
for i in range(M) :
A[L[i][0]] -= 1
A[L[i][1]] += 1
if red[L[i][0]] == 1 :
red[L[i][1]] = 1
if A[L[i][0]] == 0 :
red[L[i][0]] = 0
ans = sum(red)
print(ans)
| N,M = list(map(int,input().split()))
L = [1 for i in range(N)]
R = [0 for i in range(N)]
R[0] = 1
for i in range(M) :
x,y = list(map(int,input().split()))
x -= 1
y -= 1
L[x] -= 1
L[y] += 1
if R[x] == 1 and R[y] == 0 :
R[y] = 1
if L[x] == 0 and R[x] == 1 :
R[x] = 0
print((sum(R)))
| p04034 |
(N, M), *AB = [list(map(int, s.split())) for s in open(0)]
cnt = [1] * N
possibly_red = [False] * N
possibly_red[0] = True
for a, b in AB:
a -= 1
b -= 1
cnt[a] -= 1
cnt[b] += 1
if possibly_red[a]:
possibly_red[b] = True
if cnt[a] == 0:
possibly_red[a] = False
print((sum(possibly_red)))
| N, M, *xy = list(map(int, open(0).read().split()))
boxes = [{"count": 1, "red": False} for _ in range(N)]
boxes[0]["red"] = True
for x, y in zip(*[iter(xy)] * 2):
x -= 1
y -= 1
if boxes[x]["red"]:
boxes[y]["red"] = True
if boxes[x]["count"] == 1:
boxes[x]["red"] = False
boxes[x]["count"] -= 1
boxes[y]["count"] += 1
print((sum(b["red"] for b in boxes)))
| p04034 |
#!/usr/bin/env python3
N, M = list(map(int, input().split()))
xy_table = []
for _ in range(M):
x, y = list(map(int, input().split()))
xy_table.append((x, y))
red_box_list = [1]
# 添字0はダミー
# 添字 = 箱の番号として扱う
n_box_list = [0] + [1] * N
for xy in xy_table:
x, y = xy
n_box_list[x] -= 1
n_box_list[y] += 1
if x in red_box_list:
if y not in red_box_list:
red_box_list.append(y)
if n_box_list[x] == 0:
red_box_list.remove(x)
ans = len(red_box_list)
print(ans)
| #!/usr/bin/env python3
N, M = list(map(int, input().split()))
xy_table = []
for _ in range(M):
x, y = list(map(int, input().split()))
xy_table.append((x, y))
red_box_dict = {i: False for i in range(1, N + 1)}
red_box_dict[1] = True
# 添字0はダミー
# 添字 = 箱の番号として扱う
n_box_list = [0] + [1] * N
for xy in xy_table:
x, y = xy
n_box_list[x] -= 1
n_box_list[y] += 1
if red_box_dict[x]:
red_box_dict[y] = True
if n_box_list[x] == 0:
red_box_dict[x] = False
ans = len([v for v in list(red_box_dict.values()) if v])
print(ans)
| p04034 |
N, M = list(map(int, input().split()))
B = [[1, 0] for i in range(N)]
B[0][1] = 1
for i in range(M):
x, y = list(map(int, input().split()))
if B[x - 1][1] == 1:
B[y - 1][1] = 1
B[x - 1][0] -= 1
B[y - 1][0] += 1
if B[x - 1][0] == 0:
B[x - 1][1] = 0
cnt = 0
for i in range(N):
if B[i][1] == 1:
cnt += 1
print(cnt)
| N, M = list(map(int, input().split()))
B = [1]*N
R=[0]*N
R[0]=1
for i in range(M):
x, y = list(map(int, input().split()))
x-=1
y-=1
if R[x] == 1:
R[y] = 1
B[x] -= 1
B[y] += 1
if B[x] == 0:
R[x] = 0
print((sum(R)))
| p04034 |
#!/usr/bin/env python3
def main():
N, M = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(M)]
box = [1] * N
red_flag = [0] * N
red_flag[0] = 1
ans = 0
for i in range(M):
if red_flag[xy[i][0] - 1] == 1:
red_flag[xy[i][1] - 1] = 1
box[xy[i][0] - 1] -= 1
if box[xy[i][0] - 1] == 0:
red_flag[xy[i][0] - 1] = 0
box[xy[i][1] - 1] += 1
for i in range(N):
if box[i] != 0 and red_flag[i] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
def main():
N, M = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(M)]
box = [1] * N
red_flag = [0] * N
red_flag[0] = 1
ans = 0
for i in range(M):
if red_flag[xy[i][0] - 1] == 1:
red_flag[xy[i][1] - 1] = 1
box[xy[i][0] - 1] -= 1
if box[xy[i][0] - 1] == 0:
red_flag[xy[i][0] - 1] = 0
box[xy[i][1] - 1] += 1
print((sum(red_flag)))
if __name__ == "__main__":
main()
| p04034 |
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N, M = list(map(int, input().split()))
quantity = [1] * N
red = [True] + [False] * (N - 1)
for i in range(M):
x, y = list(map(int, input().split()))
quantity[x - 1] -= 1
quantity[y - 1] += 1
if red[x - 1] == True:
red[y - 1] = True
if quantity[x - 1] == 0:
red[x - 1] = False
print((red.count(True)))
resolve() | import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N,M=list(map(int,input().split()))
X, Y = [0] * M, [0] * M
for i in range(M):
X[i], Y[i] = list(map(int, input().split()))
red=[True]+[False]*(N-1)
cnt=[1]*N
for i in range(M):
cnt[X[i]-1]-=1
cnt[Y[i]-1]+=1
if red[X[i]-1]:
red[Y[i]-1]=True
if cnt[X[i]-1]==0:
red[X[i] - 1]=False
print((red.count(True)))
resolve() | p04034 |
n, m = list(map(int, input().split()))
white = [1]*n
white[0] = 0
red = [0] * n
red[0] = 1
for _ in range(m):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
if red[x] > 0:
red[y] += 1
else:
white[y] += 1
if white[x] > 0:
white[x] -= 1
else:
red[x] -= 1
ans = n-red.count(0)
print(ans)
| import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, input().split()))
red = [0] * (N + 1)
white = [1] * (N + 1)
red[1] = 1
white[1] = 0
for _ in range(M):
x, y = list(map(int, input().split()))
if red[x]:
red[y] += 1
else:
white[y] += 1
if white[x]:
white[x] -= 1
else:
red[x] -= 1
print((N-red[1:].count(0))) | p04034 |
"""
author : halo2halo
date : 18,Oct,2019
"""
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
S = readline().rstrip()
ans = 'Yes'
for i in range(len(S)):
if i % 2 == 0 and S[i] == 'L':
ans = 'No'
break
elif i % 2 == 1 and S[i] == 'R':
ans = 'No'
break
print(ans)
| """
author : halo2halo
date : 9, Jan, 2020
"""
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
S = readline().decode('utf8').rstrip()
flag1 = True
flag2 = True
Sodd = S[::2]
Seven = S[1::2]
if Sodd.count('L') != 0:
flag1 = False
if Seven.count('R') != 0:
flag2 = False
print(('Yes' if flag1 and flag2 else 'No'))
| p02910 |
from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
ts=time.time()
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
show_flg=False
show_flg=True
an=0
k=0
s=list(input())
n=len(s)
d=[['R','U','D'],['L','U','D']]
for i in range(n):
if s[i] in d[k]:
0
else:
an=1
k=1-k
print(YN[an])
| from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
ts=time.time()
sys.setrecursionlimit(10**6)
#input=sys.stdin.readline
show_flg=False
show_flg=True
an=0
k=0
s=list(input())
n=len(s)
d=[['R','U','D'],['L','U','D']]
for i in range(n):
if s[i] in d[k]:
0
else:
an=1
k=1-k
print(YN[an])
| p02910 |
def f(s):
p = True
for u in s:
if u not in ('RUD' if p else 'LUD'): return False
p ^= True
return True
print('Yes' if f(input()) else 'No')
| def f(s):
p = True
for u in s:
if u == ('L' if p else 'R'): return False
p ^= True
return True
print('Yes' if f(input()) else 'No')
| p02910 |
import queue, sys
INF = 10**9+7
n = eval(input())
p = []
for i in range(n):
p.append(int(input()))
dist = [10**7] * n
calc = [-1] * n
used = [False] * n
que = queue.PriorityQueue()
que.put((0, 0))
dist[0] = 0
while not que.empty():
co, v = que.get()
if dist[v] < co:
continue
for k in range(1, 7):
go = v+k
if go>=n:
break
if p[go] != 0:
if calc[go]==-1:
path = []
while True:
if p[go]==0:
break
if calc[go]!=-1:
go = calc[go]
break
if used[go]:
go = INF
break
used[go] = True
path.append(go)
go += p[go]
for e in path:
calc[e] = go
else:
go = calc[go]
if go==INF:
continue
if go==n-1:
print(dist[v]+1)
exit(0)
if dist[v] + 1 < dist[go]:
dist[go] = dist[v] + 1
que.put((dist[go], go)) | import queue
INF = 10**9
n = eval(input())
p = [i+int(input()) for i in range(n)]
used = [0] * n
idx = 0
for i in range(n):
if p[i]!=i:
path = []
go = i
idx += 1
while go!=INF and p[go]!=go:
if used[go]==idx:
go = INF
break
used[go] = idx
path.append(go)
go = p[go]
for e in path:
p[e] = go
dist = [INF] * n
que = queue.Queue()
que.put(0)
dist[0] = 0
while not que.empty():
v = que.get()
for k in range(1, min(7, n-v)):
go = p[v+k]
if go==n-1:
print(dist[v]+1)
exit(0)
if go!=INF and dist[v] + 1 < dist[go]:
dist[go] = dist[v] + 1
que.put(go) | p01449 |
n = int(eval(input()))
k = int(eval(input()))
outcome = 1
for i in range(n):
outcome = min(outcome*2, outcome+k)
print(outcome) | n = int(eval(input()))
k = int(eval(input()))
ans = 1
for _ in range(n):
ans = min(ans+k,2*ans)
print(ans) | p03564 |
n = int(eval(input()))
k = int(eval(input()))
cur = 1
for i in range(n):
if (cur * 2) > (cur + k):
cur += k
else:
cur *= 2
print(cur) | n = int(eval(input()))
k = int(eval(input()))
res = 1
for i in range(n):
if res > k:
res += k
else:
res *= 2
print(res) | p03564 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,K = I(),I()
ans = 10**6
for i in range(N+1):
a = 2**i
a += K*(N-i)
ans = min(ans,a)
print(ans)
| import sys
def I(): return int(sys.stdin.readline().rstrip())
N,K = I(),I()
print((min(2**i+K*(N-i) for i in range(N+1))))
| p03564 |
n = int(eval(input()))
k = int(eval(input()))
ans = 10**10
for i in range(2**n):
m = 1
for j in range(n):
if (i>>j)&1 == 1:
m *= 2
else:
m += k
ans = min(m,ans)
print(ans) | n = int(eval(input()))
k = int(eval(input()))
ans = 1
for i in range(n):
ans = min(2*ans,ans+k)
print(ans) | p03564 |
N = int(eval(input()))
K = int(eval(input()))
ans = None
for i in range(2 ** N):
tmp = 1
for j in range(N):
if ((i >> j) &1):
tmp += K
else:
tmp *= 2
if ans == None:
ans = tmp
else:
ans = min(ans, tmp)
print (ans)
| import itertools
N = int(eval(input()))
K = int(eval(input()))
ans = 10 ** 18
for i in itertools.product('AB', repeat = N):
tmp = 1
for j in i:
if j == 'A':
tmp *= 2
else:
tmp += K
# print (i, tmp)
ans = min(ans, tmp)
print (ans)
| p03564 |
n = int(eval(input()))
k = int(eval(input()))
a = [1]
for i in range(n):
if a[i] < k:
a[i] = 2*a[i]
a.append(a[i])
else:
a[i] = a[i] + k
a.append(a[i])
print((a[n-1])) | n = int(eval(input()))
k = int(eval(input()))
s = 1
for i in range(n):
s = min(s+k,s*2)
print(s) | p03564 |
N,K=int(eval(input())),int(eval(input()))
ans=10**10
for i in range(2**N):
tmp=1
for j in range(N):
if (i>>(N-j-1)&1)==1:
tmp*=2
else:
tmp+=K
ans=min(ans,tmp)
print(ans) | N,K=int(eval(input())),int(eval(input()))
M=[0]*(N+1)
M[0]=1
for i in range(1,N+1):
M[i]=min(M[i-1]*2,M[i-1]+K)
print((M[N])) | p03564 |
n = int(eval(input()))
k = int(eval(input()))
i = 1
while i < k:
i *= 2
n -= 1
while n != 0:
i += k
n -= 1
print(i) | n = int(eval(input()))
k = int(eval(input()))
num = 1
for i in range(n):
if num + k < num * 2:
num += k
else:
num *= 2
print(num) | p03564 |
N = int(eval(input()))
K = int(eval(input()))
ans = 10**18
for state in range(1 << N):
now = 1
for d in range(N):
if (state & (1 << d)) == 0:
now *= 2
else:
now += K
ans = min(ans, now)
print(ans)
| N = int(eval(input()))
K = int(eval(input()))
ans = 1
for _ in range(N):
if ans < K:
ans *= 2
else:
ans += K
print(ans)
| p03564 |
N=int(eval(input()))
K=int(eval(input()))
n=1
for i in range(N):
if n<K:
n*=2
else:
n+=K
print(n)
| def solve():
n = int(eval(input()))
k = int(eval(input()))
ans = 1
for i in range(n):
if ans < k:
ans *= 2
else:
ans += k
print(ans)
if __name__ == "__main__":
solve()
| p03564 |
n = int(eval(input()))
k = int(eval(input()))
res = 1
for i in range(n):
if res * 2 - res < k:
res *= 2
else:
res += k
print(res) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
k = int(eval(input()))
res = 1
for _ in range(n):
if res < k:
res *= 2
else:
res += k
print(res)
if __name__ == '__main__':
resolve()
| p03564 |
N = int(eval(input()))
K = int(eval(input()))
min_m = 10 ** 10
for i in range(2 ** N):
m = 1
for n in range(N):
if i & (1 << n):
m *= 2
else:
m += K
min_m = min(min_m, m)
print(min_m)
| N = int(eval(input()))
K = int(eval(input()))
# min_m = 10 ** 10
# for i in range(2 ** N):
# m = 1
# for n in range(N):
# if i & (1 << n):
# m *= 2
# else:
# m += K
# min_m = min(min_m, m)
m = 1
for i in range(N):
m = min(m * 2, m + K)
print(m)
| p03564 |
N = int(eval(input()))
K = int(eval(input()))
sum = 1
for i in range(N):
if sum*2 <= sum+K:
sum *= 2
else:
sum += K
print(sum)
| n=int(eval(input()))
k=int(eval(input()))
ans=1
for i in range(n):
ans=min(ans*2,ans+k)
print(ans) | p03564 |
N=int(eval(input()))
K=int(eval(input()))
ans=float('inf')
for i in range(2**N):
bi=list(format(i,'b').zfill(N))
now=1
for b in bi:
if b=='0':
now*=2
else:
now+=K
if now<ans:
ans=now
print(ans) | N=int(eval(input()))
K=int(eval(input()))
ans=1
for i in range(N):
ans=min(ans*2,ans+K)
print(ans) | p03564 |
n=int(eval(input()))
k=int(eval(input()))
s=1
for i in range(n):s=min(s*2,s+k)
print(s) | N=int(eval(input()))
K=int(eval(input()))
display=1
for i in range(N):
display=min(display*2,display+K)
print(display) | p03564 |
num = 1
n = int(eval(input()))
k = int(eval(input()))
for i in range(n):
if num < k:
num = num*2
else:
num += k
print(num) | n = int(eval(input()))
k = int(eval(input()))
start = 1
for i in range(n):
start = min(start*2,start+k)
print(start)
| p03564 |
a = int(eval(input()))
b = int(eval(input()))
i = 0
p= 1
while i < a:
if p > b:
p = p+b
i = i+1
else:
p = 2*p
i = i+1
print(p) | a = int(eval(input()))
b = int(eval(input()))
ans = 1
for i in range(a):
ans = min(ans * 2,ans + b)
print(ans) | p03564 |
n = int(eval(input()))
k = int(eval(input()))
val = 1
for i in range(n):
val = min(val + k, val * 2)
print(val) | n = int(eval(input()))
k = int(eval(input()))
p = 1
for _ in range(n):
if p * 2 < p + k:
p *= 2
else:
p += k
print(p) | p03564 |
#!/usr/bin/env python3
N = int(eval(input()))
K = int(eval(input()))
num = 1
for i in range(N):
if num <= K:
num *= 2
else:
num += K
print(num)
| N=int(eval(input()))
K=int(eval(input()))
count=1
for i in range(N):
if(count*2<count+K):
count*=2
else:
count+=K
print(count)
| p03564 |
n = int(eval(input()))
k = int(eval(input()))
val = 1
for i in range(n):
if val > k:
val += k
else:
val *= 2
print(val) | x = int(input())
y = int(input())
d = 1
for i in range(0, x):
if y > d:
d += d
else:
d += y
print(d)
| p03564 |
N = int(eval(input()))
K = int(eval(input()))
ans = 1
for i in range(N):
if(ans*2 < ans+K):
ans *= 2
else:
ans += K
print(ans) | N = int(eval(input()))
K = int(eval(input()))
ans = 1
for i in range(N):
ans = min(ans*2, ans+K)
print(ans) | p03564 |
ans=1
n=int(eval(input()))
k=int(eval(input()))
for i in range(n):
ans=min(ans+k,ans*2)
print(ans) | n=int(eval(input()))
k=int(eval(input()))
ans=1
for i in range(n):
if k>ans:
ans*=2
else : ans+=k
print(ans) | p03564 |
N = int(eval(input()))
K = int(eval(input()))
ans = float('inf')
for i in range(2**N):
now = 1
for j in range(N):
if i>>j & 1:
now *= 2
else:
now += K
ans = min(ans, now)
print(ans) | N = int(eval(input()))
K = int(eval(input()))
now = 1
for i in range(N):
now = min(now*2, now+K)
print(now) | p03564 |
n = int(eval(input()))
k = int(eval(input()))
ans = 1
for i in range(n):
if ans*2 < ans + k:
ans *= 2
else:
ans += k
print(ans) | n = int(eval(input()))
k = int(eval(input()))
ans = 1
for i in range(n):
ans = min(ans*2, ans + k)
print(ans) | p03564 |
s = input()
p = "ABC"
used = set()
while s != p:
idx = 0
c = [0]*3
while idx < len(s):
if idx+3 <= len(s) and s[idx:idx+3] == p:
idx += 3
else:
c[p.index(s[idx])] += 1
idx += 1
if sum(e == 0 for e in c) != 1 or sum(c) == s:
print("No")
exit(0)
s = s.replace("ABC", p[[i for i in [0,1,2] if c[i]==0][0]])
print("Yes") | s = input()
p = "ABC"
used = set()
while s != p:
idx = 0
c = [0]*3
while idx < len(s):
if idx+3 <= len(s) and s[idx:idx+3] == p:
idx += 3
else:
c[p.index(s[idx])] += 1
idx += 1
if sum(e == 0 for e in c) != 1 or sum(c) == len(s):
print("No")
exit(0)
s = s.replace("ABC", p[[i for i in [0,1,2] if c[i]==0][0]])
print("Yes") | p01811 |
#!/usr/bin/python
if __name__ == "__main__":
S = input()
c = ['A','B','C']
while True:
if S == "ABC":
print("Yes")
break
T = S.strip().split("ABC")
P = ''.join(T)
cnt = 0
for x in c:
if x in P:
cnt += 1
else:
S = x.join(T)
if cnt != 2:
print("No")
break | #!/usr/bin/python
if __name__ == "__main__":
S = input()
c = ['A','B','C']
while True:
if len(S) <= 3:
print("Yes" if S == "ABC" else "No")
break
T = S.strip().split("ABC")
if len(T) == 1:
print("No")
break
P = ''.join(T)
cnt = 0
for x in c:
if x in P:
cnt += 1
else:
S = x.join(T)
if cnt != 2:
print("No")
break | p01811 |
#!/usr/bin/python
if __name__ == "__main__":
S = input()
c = ['A','B','C']
while True:
if len(S) <= 3:
print("Yes" if S == "ABC" else "No")
break
T = S.strip().split("ABC")
if len(T) == 1:
print("No")
break
P = ''.join(T)
cnt = 0
for x in c:
if x in P:
cnt += 1
else:
S = x.join(T)
if cnt != 2:
print("No")
break | #!/usr/bin/python
if __name__ == "__main__":
S = input()
c = ['A','B','C']
while True:
if len(S) <= 3:
print("Yes" if S == "ABC" else "No")
break
T = S.strip().split("ABC")
P = ''.join(T)
cnt = 0
for x in c:
if x in P:
cnt += 1
else:
S = x.join(T)
if len(T) == 1 or cnt != 2:
print("No")
break | p01811 |
# 同じインデックスの重複を除くので、関数の呼び出し回数が少し少ないはず。
# ただ、重複を除く分のオーバーヘッドがあるので、
# fmm, fmo, fooが軽い関数だと、スピードはそこまで出ない。
MOD = 998244353
mask = (1 << 32) - 1
mask20 = (1 << 20) - 1
mask40 = (1 << 40) - 1
class LazySegmentTree:
__slots__ = ["n", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, monoid_data, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
self.n = len(monoid_data)
self.data = monoid_data * 2
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
def replace(self, index, value):
index += self.n
# propagation
for shift in range(index.bit_length()-1, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def effect(self, l, r, operator):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
l0 //= 2
r0 //= 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
for i in indices:
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
l0 //= 2
r0 //= 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
# Monoid は (値 << 32) + 要素数 にする。
# Operator も (b << 32) + c
def main():
import sys
input = sys.stdin.buffer.readline
def fmm(m1, m2):
m = m1 + m2
return (((m >> 32) % MOD) << 32) + (m & mask)
def fmo(m1, o1):
val = m1 >> 32
cnt = m1 & mask
b = o1 >> 32
c = o1 & mask
return (((b * val + c * cnt) % MOD) << 32) + cnt
def foo(o1, o2):
b1 = o1 >> 32
c1 = o1 & mask
b2 = o2 >> 32
c2 = o2 & mask
b = b1 * b2 % MOD
c = (c1 * b2 + c2) % MOD
return (b << 32) + c
N, Q = list(map(int, input().split()))
monoid_data = [(A << 32) + 1 for A in map(int, input().split())]
lst = LazySegmentTree(monoid_data, 1, 1 << 32, fmm, fmo, foo)
for _ in range(Q):
q, *k = list(map(int, input().split()))
if q == 0:
o = (k[2] << 32) + k[3]
lst.effect(k[0], k[1], o)
else:
print((lst.folded(k[0], k[1]) >> 32))
def test():
import random
def madd(a, b):
return (a + b) % MOD
def mmul(a, b):
return a * b % MOD
lst = LazySegmentTree([0] * 10, 0, 1, madd, mmul, mmul)
ls = [0] * 10
for _ in range(10000000):
if random.randint(0, 1): # effect
l = random.randint(0, 9)
r = random.randint(l+1, 10)
e = random.randint(1, 782)
lst.effect(l, r, e)
for i in range(l, r):
ls[i] *= e
ls[i] %= MOD
else:
l = random.randint(0, 9)
r = random.randint(l+1, 10)
if lst.folded(l, r) != sum(ls[l:r]):
print(ls)
print((l, r))
print((lst.folded(l, r)))
def atc():
# Monoid: ((0の数) << 60) + ((1の数) << 40) + (転倒数)
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [1099511627776 if A == b'1' else 1152921504606846976 for A in input().split()]
def fmm(m1, m2):
return m1 + m2 + ((m1 >> 40) & mask20) * (m2 >> 60)
def fmo(m1, o1):
if o1:
cnt = m1 & mask40
c1 = (m1 >> 40) & mask20
c0 = m1 >> 60
return (c1 << 60) + (c0 << 40) + ((c0 * c1) - cnt)
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, 0, 0, fmm, fmo, foo)
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
print((lst.folded(L-1, R) & mask40))
def atc2():
# Monoid: ((0の数), (1の数), (転倒数))
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [(0, 1, 0) if A == b'1' else (1, 0, 0) for A in input().split()]
def fmm(m1, m2):
return (m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2] + m1[1] * m2[0])
def fmo(m1, o1):
if o1:
return (m1[1], m1[0], m1[0] * m1[1] - m1[2])
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, (0, 0, 0), 0, fmm, fmo, foo)
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
print((lst.folded(L-1, R)[2]))
def mainbignum():
import sys
input = sys.stdin.buffer.readline
bignum = 10 ** 9
def fmm(m1, m2):
m = m1 + m2
q, r = divmod(m, bignum)
return (q % MOD * bignum) + r
def fmo(m1, o1):
val, cnt = divmod(m1, bignum)
b, c = divmod(o1, bignum)
return (((b * val + c * cnt) % MOD) * bignum) + cnt
def foo(o1, o2):
b1, c1 = divmod(o1, bignum)
b2, c2 = divmod(o2, bignum)
b = b1 * b2 % MOD
c = (c1 * b2 + c2) % MOD
return (b * bignum) + c
N, Q = list(map(int, input().split()))
monoid_data = [(A *bignum) + 1 for A in map(int, input().split())]
lst = LazySegmentTree(monoid_data, 1, bignum, fmm, fmo, foo)
for _ in range(Q):
q, *k = list(map(int, input().split()))
if q == 0:
o = (k[2] * bignum) + k[3]
lst.effect(k[0], k[1], o)
else:
print((lst.folded(k[0], k[1]) // bignum))
if __name__ == "__main__":
atc2() | # 同じインデックスの重複を除くので、関数の呼び出し回数が少し少ないはず。
# ただ、重複を除く分のオーバーヘッドがあるので、
# fmm, fmo, fooが軽い関数だと、スピードはそこまで出ない。
class LazySegmentTree:
__slots__ = ["n", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, monoid_data, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
self.n = len(monoid_data)
self.data = monoid_data * 2
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
def replace(self, index, value):
index += self.n
# propagation
for shift in range(index.bit_length()-1, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def effect(self, l, r, operator):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l // (l & -l)) // 2
r0 = (r // (r & -r) - 1) // 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
for i in indices:
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l // (l & -l)) // 2
r0 = (r // (r & -r) - 1) // 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
def atc2():
# Monoid: ((0の数), (1の数), (転倒数))
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [(0, 1, 0) if A == b'1' else (1, 0, 0) for A in input().split()]
def fmm(m1, m2):
return (m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2] + m1[1] * m2[0])
def fmo(m1, o1):
if o1:
return (m1[1], m1[0], m1[0] * m1[1] - m1[2])
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, (0, 0, 0), 0, fmm, fmo, foo)
ans = []
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
ans.append(lst.folded(L-1, R)[2])
print(('\n'.join(map(str, ans))))
if __name__ == "__main__":
atc2() | p02569 |
# 入力チェックオフ
class LazySegmentTree:
__slots__ = ["n", "original_size", "log", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, length_or_list, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
if isinstance(length_or_list, int):
self.original_size = length_or_list
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * (self.n * 2)
self.lazy = [self.oe] * (self.n * 2)
elif isinstance(length_or_list, list):
self.original_size = len(length_or_list)
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * self.n + length_or_list + [self.me] * (self.n - self.original_size)
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
else:
raise TypeError(f"The argument 'length_or_list' must be an integer or a list, not {type(length_or_list).__name__}")
def replace(self, index, value):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def __getitem__(self, index):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# self.data[index] = self.fmo(self.data[index], self.lazy[index])
# self.lazy[index] = self.oe
return self.data[index]
def effect(self, l, r, operator):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
if l == r:
return
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(l0.bit_length(), 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(r0.bit_length(), 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
i = l0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
i = r0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
l += self.n
r += self.n
# propagation
for shift in range(self.log, 0, -1):
i = l >> shift
if i << shift != l:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
i = r >> shift
if i << shift != r:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
def atc2():
# Monoid: ((0の数), (1の数), (転倒数))
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [(0, 1, 0) if A == b'1' else (1, 0, 0) for A in input().split()]
def fmm(m1, m2):
return (m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2] + m1[1] * m2[0])
def fmo(m1, o1):
if o1:
return (m1[1], m1[0], m1[0] * m1[1] - m1[2])
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, (0, 0, 0), 0, fmm, fmo, foo)
ans = []
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
ans.append(lst.folded(L-1, R)[2])
print(('\n'.join(map(str, ans))))
if __name__ == "__main__":
atc2() | # 入力チェックオフ
class LazySegmentTree:
__slots__ = ["n", "original_size", "log", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, length_or_list, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
if isinstance(length_or_list, int):
self.original_size = length_or_list
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * (self.n * 2)
self.lazy = [self.oe] * (self.n * 2)
elif isinstance(length_or_list, list):
self.original_size = len(length_or_list)
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * self.n + length_or_list + [self.me] * (self.n - self.original_size)
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
else:
raise TypeError(f"The argument 'length_or_list' must be an integer or a list, not {type(length_or_list).__name__}")
def replace(self, index, value):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def __getitem__(self, index):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# self.data[index] = self.fmo(self.data[index], self.lazy[index])
# self.lazy[index] = self.oe
return self.data[index]
def effect(self, l, r, operator):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
if l == r:
return
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(self.log, 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(self.log, 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
i = l0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
i = r0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
l += self.n
r += self.n
# propagation
for shift in range(self.log, 0, -1):
i = l >> shift
if i << shift != l:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
i = r >> shift
if i << shift != r:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
def atc2():
# Monoid: ((0の数), (1の数), (転倒数))
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [(0, 1, 0) if A == b'1' else (1, 0, 0) for A in input().split()]
def fmm(m1, m2):
return (m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2] + m1[1] * m2[0])
def fmo(m1, o1):
if o1:
return (m1[1], m1[0], m1[0] * m1[1] - m1[2])
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, (0, 0, 0), 0, fmm, fmo, foo)
ans = []
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
ans.append(lst.folded(L-1, R)[2])
print(('\n'.join(map(str, ans))))
if __name__ == "__main__":
atc2() | p02569 |
# 入力チェックオフ
class LazySegmentTree:
__slots__ = ["n", "original_size", "log", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, length_or_list, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
if isinstance(length_or_list, int):
self.original_size = length_or_list
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * (self.n * 2)
self.lazy = [self.oe] * (self.n * 2)
elif isinstance(length_or_list, list):
self.original_size = len(length_or_list)
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * self.n + length_or_list + [self.me] * (self.n - self.original_size)
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
else:
raise TypeError(f"The argument 'length_or_list' must be an integer or a list, not {type(length_or_list).__name__}")
def replace(self, index, value):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def __getitem__(self, index):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# self.data[index] = self.fmo(self.data[index], self.lazy[index])
# self.lazy[index] = self.oe
return self.data[index]
def effect(self, l, r, operator):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
if l == r:
return
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(self.log, 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(self.log, 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
i = l0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
i = r0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
l += self.n
r += self.n
# propagation
for shift in range(self.log, 0, -1):
i = l >> shift
if i << shift != l:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
i = r >> shift
if i << shift != r:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
def atc2():
# Monoid: ((0の数), (1の数), (転倒数))
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [(0, 1, 0) if A == b'1' else (1, 0, 0) for A in input().split()]
def fmm(m1, m2):
return (m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2] + m1[1] * m2[0])
def fmo(m1, o1):
if o1:
return (m1[1], m1[0], m1[0] * m1[1] - m1[2])
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, (0, 0, 0), 0, fmm, fmo, foo)
ans = []
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
ans.append(lst.folded(L-1, R)[2])
print(('\n'.join(map(str, ans))))
if __name__ == "__main__":
atc2() | # 入力チェックオフ
class LazySegmentTree:
__slots__ = ["n", "original_size", "log", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, length_or_list, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
if isinstance(length_or_list, int):
self.original_size = length_or_list
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * (self.n * 2)
self.lazy = [self.oe] * (self.n * 2)
elif isinstance(length_or_list, list):
self.original_size = len(length_or_list)
self.log = (self.original_size - 1).bit_length()
self.n = 1 << self.log
self.data = [self.me] * self.n + length_or_list + [self.me] * (self.n - self.original_size)
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
else:
raise TypeError(f"The argument 'length_or_list' must be an integer or a list, not {type(length_or_list).__name__}")
def replace(self, index, value):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def __getitem__(self, index):
# if index < -self.original_size or self.original_size <= index:
# raise IndexError("LazySegmentTree index out of range")
# if index < 0:
# index += self.original_size
index += self.n
# propagation
for shift in range(self.log, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# self.data[index] = self.fmo(self.data[index], self.lazy[index])
# self.lazy[index] = self.oe
return self.data[index]
def effect(self, l, r, operator):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
if l == r:
return
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(self.log, 0, -1):
i = l >> shift
if i << shift != l:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
i = r >> shift
if i << shift != r:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
i = l0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
i = r0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
# if l < 0:
# l += self.original_size
# if r < 0:
# r += self.original_size
# if not 0 <= l <= r <= self.original_size:
# raise IndexError("LazySegmentTree index out of range")
l += self.n
r += self.n
# propagation
for shift in range(self.log, 0, -1):
i = l >> shift
if i << shift != l:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
i = r >> shift
if i << shift != r:
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
def atc2():
# Monoid: ((0の数), (1の数), (転倒数))
# Operator: 反転するか? (1 or 0)
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
monoid_data = [(0, 1, 0) if A == b'1' else (1, 0, 0) for A in input().split()]
def fmm(m1, m2):
return (m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2] + m1[1] * m2[0])
def fmo(m1, o1):
if o1:
return (m1[1], m1[0], m1[0] * m1[1] - m1[2])
else:
return m1
def foo(o1, o2):
return o1 ^ o2
lst = LazySegmentTree(monoid_data, (0, 0, 0), 0, fmm, fmo, foo)
ans = []
for _ in range(Q):
T, L, R = list(map(int, input().split()))
if T == 1:
lst.effect(L-1, R, 1)
else:
ans.append(lst.folded(L-1, R)[2])
print(('\n'.join(map(str, ans))))
if __name__ == "__main__":
atc2() | p02569 |
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [e] * (2 * self.size)
self.lz = [id] * (self.size)
def update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size:
self.lz[k] = self.composition(f, self.lz[k])
def push(self, k):
self.all_apply(2 * k, self.lz[k])
self.all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.d[self.size + i] = a
for i in range(1, self.size)[::-1]:
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.d[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
from operator import xor
N, Q = list(map(int, input().split()))
def op(x, y):
x0, x1, x2 = x
y0, y1, y2 = y
return x0 + y0, x1 + y1, x2 + y2 + x1 * y0
def mapping(p, x):
x0, x1, x2 = x
if p:
return x1, x0, x0 * x1 - x2
else:
return x0, x1, x2
arr = [(1 - a, a, 0) for a in map(int, input().split())]
lst = LazySegmentTree(N, op, (0, 0, 0), mapping, xor, 0)
lst.build(arr)
res = list()
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
lst.range_apply(l - 1, r, 1)
else:
res.append(lst.prod(l - 1, r)[2])
print(('\n'.join(map(str, res)))) | class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [e] * (2 * self.size)
self.lz = [id] * (self.size)
def update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size:
self.lz[k] = self.composition(f, self.lz[k])
def push(self, k):
self.all_apply(2 * k, self.lz[k])
self.all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.d[self.size + i] = a
for i in range(1, self.size)[::-1]:
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.d[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
def op(x, y):
x0, x1, x2 = x
y0, y1, y2 = y
return x0 + y0, x1 + y1, x2 + y2 + x1 * y0
def mapping(p, x):
x0, x1, x2 = x
if p:
return x1, x0, x0 * x1 - x2
else:
return x0, x1, x2
def composition(x, y):
return x ^ y
arr = [(1 - a, a, 0) for a in map(int, input().split())]
lst = LazySegmentTree(N, op, (0, 0, 0), mapping, composition, 0)
lst.build(arr)
res = list()
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
lst.range_apply(l - 1, r, 1)
else:
res.append(lst.prod(l - 1, r)[2])
print(('\n'.join(map(str, res)))) | p02569 |
#-------最強ライブラリLazy Segtree(Python)------
#Please don't say you are lazy ｗｗｗｗｗｗｗｗ
#だって Python なら TLE ｗｗｗｗｗｗｗｗｗ
class lazy_segtree:
# 区間更新をする遅延評価セグメント木
def __init__(s, S, op, e, F, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(l, g):
if l == s._n: return _n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s,push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
#-------最強ライブラリここまで------
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def main():
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
TLR = [list(map(int, input().split())) for _ in range(Q)]
a = []
for i in A:
if i == 0:
a.append([1, 0, 0])
else:
a.append([0, 1, 0])
_ = 0
seg = lazy_segtree(_, op, e, _, mapping, composition, id, a)
for i in range(Q):
t, l, r = TLR[i]
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
print((seg.prod(l, r)[2]))
main() | #-------最強ライブラリLazy Segtree(Python)------
#動作確認
class lazy_segtree:
#遅延評価セグメント木
def __init__(s, S, op, e, F, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(l, g):
if l == s._n: return _n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s,push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
#-------最強ライブラリここまで------
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def main():
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
TLR = [list(map(int, input().split())) for _ in range(Q)]
a = []
for i in A:
if i == 0:
a.append([1, 0, 0])
else:
a.append([0, 1, 0])
_ = 0
seg = lazy_segtree(_, op, e, _, mapping, composition, id, a)
for i in range(Q):
t, l, r = TLR[i]
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
print((seg.prod(l, r)[2]))
main() | p02569 |
#-------最強ライブラリLazy Segtree(Python)------
#動作確認
class lazy_segtree:
#遅延評価セグメント木
def __init__(s, S, op, e, F, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(l, g):
if l == s._n: return _n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s,push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
#-------最強ライブラリここまで------
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def main():
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
TLR = [list(map(int, input().split())) for _ in range(Q)]
a = []
for i in A:
if i == 0:
a.append([1, 0, 0])
else:
a.append([0, 1, 0])
_ = 0
seg = lazy_segtree(_, op, e, _, mapping, composition, id, a)
for i in range(Q):
t, l, r = TLR[i]
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
print((seg.prod(l, r)[2]))
main() | #-------最強ライブラリLazy Segtree(Python)ver25252------
#未使用関数修正・確認
class lazy_segtree:
#遅延評価セグメント木
def __init__(s, S, op, e, F, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return s.d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(s, l, g):
if l == s._n: return _n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(s, r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s.push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
#-------最強ライブラリここまで------
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def g(x):
return x[2] <= 1
def main():
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
TLR = [list(map(int, input().split())) for _ in range(Q)]
a = []
for i in A:
if i == 0:
a.append([1, 0, 0])
else:
a.append([0, 1, 0])
_ = 0
seg = lazy_segtree(_, op, e, _, mapping, composition, id, a)
for i in range(Q):
t, l, r = TLR[i]
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
print((seg.prod(l, r)[2]))
#test
seg.set(0, [1, 0, 0])
g1 = seg.get(0)
seg.set(0, [0, 1, 0])
g2 = seg.get(0)
a = seg.all_prod()
r = seg.max_right(0, g)
l = seg.min_left(N, g)
#print(g1, g2, a, r, l)
main()
| p02569 |
class lazy_segtree:
#遅延評価セグメント木
def __init__(s, op, e, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return s.e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return s.d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(s, l, g):
if l == s._n: return s._n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(s, r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s.push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
def op(l, r):
return array.array("l", [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]])
def e():
return array.array("l", [0, 0, 0])
def mapping(l, r):
if (not l): return r
return array.array("l", [r[1], r[0], r[1] * r[0] - r[2]])
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def g(x):
return x[2] <= 1
import array
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
TLR = [list(map(int, input().split())) for _ in range(Q)]
a = []
for i in A:
if i == 0:
a.append(array.array("l", [1, 0, 0]))
else:
a.append(array.array("l", [0, 1, 0]))
_ = 0
seg = lazy_segtree(op, e, mapping, composition, id, a)
for i in range(Q):
t, l, r = TLR[i]
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
print((seg.prod(l, r)[2]))
| class lazy_segtree:
#遅延評価セグメント木
def __init__(s, op, e, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return s.e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return s.d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(s, l, g):
if l == s._n: return s._n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(s, r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s.push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def g(x):
return x[2] <= 1
import array
N, Q = list(map(int, input().split()))
a = [(0, 1, 0) if A == "1" else (1, 0, 0) for A in input().split()]
seg = lazy_segtree(op, e, mapping, composition, id, a)
ans = []
for i in range(Q):
t, l, r = list(map(int, input().split()))
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
ans.append(seg.prod(l, r)[2])
for i in ans:
print(i)
| p02569 |
class lazy_segtree:
#遅延評価セグメント木
def __init__(s, op, e, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return s.e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return s.d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(s, l, g):
if l == s._n: return s._n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(s, r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s.push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def g(x):
return x[2] <= 1
import array
N, Q = list(map(int, input().split()))
a = [(0, 1, 0) if A == "1" else (1, 0, 0) for A in input().split()]
seg = lazy_segtree(op, e, mapping, composition, id, a)
ans = []
for i in range(Q):
t, l, r = list(map(int, input().split()))
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
ans.append(seg.prod(l, r)[2])
for i in ans:
print(i)
| class lazy_segtree:
#遅延評価セグメント木
def __init__(s, op, e, mapping, composition, id, v):
if type(v) is int: v = [e()] * v
s._n = len(v)
s.log = s.ceil_pow2(s._n)
s.size = 1 << s.log
s.d = [e()] * (2 * s.size)
s.lz = [id()] * s.size
s.e = e
s.op = op
s.mapping = mapping
s.composition = composition
s.id = id
for i in range(s._n): s.d[s.size + i] = v[i]
for i in range(s.size - 1, 0, -1): s.update(i)
# 1点更新
def set(s, p, x):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = x
for i in range(1, s.log + 1): s.update(p >> i)
# 1点取得
def get(s, p):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
return s.d[p]
# 区間演算
def prod(s, l, r):
if l == r: return s.e()
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push(r >> i)
sml, smr = s.e(), s.e()
while (l < r):
if l & 1:
sml = s.op(sml, s.d[l])
l += 1
if r & 1:
r -= 1
smr = s.op(s.d[r], smr)
l >>= 1
r >>= 1
return s.op(sml, smr)
# 全体演算
def all_prod(s): return s.d[1]
# 1点写像
def apply(s, p, f):
p += s.size
for i in range(s.log, 0, -1): s.push(p >> i)
s.d[p] = s.mapping(f, s.d[p])
for i in range(1, s.log + 1): s.update(p >> i)
# 区間写像
def apply(s, l, r, f):
if l == r: return
l += s.size
r += s.size
for i in range(s.log, 0, -1):
if (((l >> i) << i) != l): s.push(l >> i)
if (((r >> i) << i) != r): s.push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
sml = s.all_apply(l, f)
l += 1
if r & 1:
r -= 1
smr = s.all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, s.log + 1):
if (((l >> i) << i) != l): s.update(l >> i)
if (((r >> i) << i) != r): s.update((r - 1) >> i)
# L固定時の最長区間のR
def max_right(s, l, g):
if l == s._n: return s._n
l += s.size
for i in range(s.log, 0, -1): s.push(l >> i)
sm = s.e()
while True:
while (l % 2 == 0): l >>= 1
if not g(s.op(sm, s.d[l])):
while l < s.size:
s.push(l)
l = 2 * l
if g(s.op(sm, s.d[l])):
sm = s.op(sm, s.d[l])
l += 1
return l - s.size
sm = s.op(sm, s.d[l])
l += 1
if (l & -l) == l: break
return s._n
# R固定時の最長区間のL
def min_left(s, r, g):
if r == 0: return 0
r += s.size
for i in range(s.log, 0, -1): s.push((r - 1) >> i)
sm = s.e()
while True:
r -= 1
while r > 1 and (r % 2): r >>= 1
if not g(s.op(s.d[r], sm)):
while r < s.size:
s.push(r)
r = 2 * r + 1
if g(s.op(s.d[r], sm)):
sm = s.op(s.d[r], sm)
r -= 1
return r + 1 - s.size
sm = s.op(s.d[r], sm)
if (r & - r) == r: break
return 0
def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
def all_apply(s, k, f):
s.d[k] = s.mapping(f, s.d[k])
if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
def push(s, k):
s.all_apply(2 * k, s.lz[k])
s.all_apply(2 * k + 1, s.lz[k])
s.lz[k] = s.id()
def ceil_pow2(s, n):
x = 0
while (1 << x) < n: x += 1
return x
def op(l, r):
return [l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0]]
def e():
return [0, 0, 0]
def mapping(l, r):
if (not l): return r
return [r[1], r[0], r[1] * r[0] - r[2]]
def composition(l, r):
return (l and not r) or (not l and r)
def id():
return False
def g(x):
return x[2] <= 1
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
a = [(0, 1, 0) if A == "1" else (1, 0, 0) for A in input().split()]
seg = lazy_segtree(op, e, mapping, composition, id, a)
ans = []
for i in range(Q):
t, l, r = list(map(int, input().split()))
l -= 1
if t == 1:
seg.apply(l, r, True)
else:
ans.append(seg.prod(l, r)[2])
for i in ans:
print(i)
| p02569 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### 遅延評価セグメント木
class LazySegmentTree:
def __init__(self, n, a=None):
"""初期化
num : n以上の最小の2のべき乗
"""
num = 1
while num<=n:
num *= 2
self.num = num
self.seg = [ninf] * (2*self.num-1)
self.lazy = [f0] * (2*self.num-1)
self.ls = [0]*(2*self.num-1)
self.rs = [0]*(2*self.num-1)
self.ls[0] = 0
self.rs[0] = self.num
for i in range(self.num-1):
self.ls[2*i+1] = self.ls[i]
self.rs[2*i+1] = (self.ls[i] + self.rs[i])//2
self.ls[2*i+2] = (self.ls[i] + self.rs[i])//2
self.rs[2*i+2] = self.rs[i]
if a is not None:
# O(n)で初期化
assert len(a)==n
for i in range(n):
self.seg[num-1+i] = a[i]
for k in range(num-2, -1, -1):
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def eval(self, k):
if self.lazy[k]==f0:
return
if k<self.num-1:
self.lazy[k*2+1] = composition(self.lazy[k], self.lazy[k*2+1])
self.lazy[k*2+2] = composition(self.lazy[k], self.lazy[k*2+2])
self.seg[k] = mapping(self.lazy[k], self.seg[k])
self.lazy[k] = f0
def eval_all(self):
for i in range(2*self.num-1):
self.eval(i)
def update(self,a,b,x=None,f=None):
"""A[a]...A[b-1]をxに更新する
"""
if f is None:
# 更新クエリ
f = lambda y: x
k = 0
q = [k] # k>=0なら行きがけ順
# 重なる区間を深さ優先探索
while q:
k = q.pop()
l,r = self.ls[k], self.rs[k]
if k>=0:
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
self.lazy[k] = composition(f, self.lazy[k])
self.eval(k)
else:
q.append(~k)
q.append(2*k+1)
q.append(2*k+2)
else:
k = ~k
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def query(self,a,b):
k = 0
l = 0
r = self.num
q = [k]
ans = ninf
# 重なる区間を深さ優先探索
while q:
k = q.pop()
l,r = self.ls[k], self.rs[k]
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
ans = op(ans, self.seg[k])
else:
q.append(2*k+2)
q.append(2*k+1)
# print(q, ans, l,r,a,b, self.seg[k])
return ans
n,q = list(map(int, input().split()))
a = list(map(int, input().split()))
# ninf = -10**9
# op = max
# mapping = lambda f,x: f(x)
# composition = lambda f1, f2: f1 if f1 is not None else f2
ninf = (0,0,0) # (転倒数, #0, #1)
op = lambda x,y: (x[0]+y[0]+x[2]*y[1], x[1]+y[1], x[2]+y[2])
mapping = lambda f,x: ((x[1]+x[2])*(x[1]+x[2]-1)//2 - (x[1]*(x[1]-1)//2) - (x[2]*(x[2]-1)//2) - x[0], x[2], x[1]) if f else x
composition = lambda f1, f2: f1^f2
f0 = False
sg = LazySegmentTree(n, [((0,1,0) if item==0 else (0,0,1)) for item in a])
ans = []
for _ in range(q):
t = tuple(map(int, input().split()))
if t[0]==1:
_, l,r = t
sg.update(l-1,r,f=True)
else:
_,l,r = t
ans.append(sg.query(l-1,r)[0])
# break
write("\n".join(map(str, ans))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### 遅延評価セグメント木
class LazySegmentTree:
def __init__(self, n, a=None):
"""初期化
num : n以上の最小の2のべき乗
"""
num = 1
v = 0
while num<=n:
num *= 2
v += 1
self.q = [None]*(2*v+10)
self.num = num
self.seg = [ninf] * (2*self.num-1)
self.lazy = [f0] * (2*self.num-1)
self.ls = [0]*(2*self.num-1)
self.rs = [0]*(2*self.num-1)
self.ls[0] = 0
self.rs[0] = self.num
for i in range(self.num-1):
self.ls[2*i+1] = self.ls[i]
self.rs[2*i+1] = (self.ls[i] + self.rs[i])//2
self.ls[2*i+2] = (self.ls[i] + self.rs[i])//2
self.rs[2*i+2] = self.rs[i]
if a is not None:
# O(n)で初期化
assert len(a)==n
for i in range(n):
self.seg[num-1+i] = a[i]
for k in range(num-2, -1, -1):
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def eval(self, k):
if self.lazy[k]==f0:
return
if k<self.num-1:
self.lazy[k*2+1] = composition(self.lazy[k], self.lazy[k*2+1])
self.lazy[k*2+2] = composition(self.lazy[k], self.lazy[k*2+2])
self.seg[k] = mapping(self.lazy[k], self.seg[k])
self.lazy[k] = f0
def eval_all(self):
for i in range(2*self.num-1):
self.eval(i)
def update(self,a,b,x=None,f=None):
"""A[a]...A[b-1]をxに更新する
"""
if f is None:
# 更新クエリ
f = lambda y: x
k = 0
self.q[0] = k # k>=0なら行きがけ順
ind = 1
# 重なる区間を深さ優先探索
while ind:
ind -= 1
k = self.q[ind]
l,r = self.ls[k], self.rs[k]
if k>=0:
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
self.lazy[k] = composition(f, self.lazy[k])
self.eval(k)
else:
self.q[ind] = ~k
self.q[ind+1] = 2*k+1
self.q[ind+2] = 2*k+2
ind += 3
# q.append(~k)
# q.append(2*k+1)
# q.append(2*k+2)
else:
k = ~k
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def query(self,a,b):
k = 0
l = 0
r = self.num
self.q[0] = k
ind = 1
ans = ninf
# 重なる区間を深さ優先探索
while ind:
ind -= 1
k = self.q[ind]
l,r = self.ls[k], self.rs[k]
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
ans = op(ans, self.seg[k])
else:
self.q[ind] = 2*k+2
self.q[ind+1] = 2*k+1
ind += 2
# q.append(2*k+2)
# q.append(2*k+1)
# print(q, ans, l,r,a,b, self.seg[k])
return ans
n,q = list(map(int, input().split()))
a = list(map(int, input().split()))
# ninf = -10**9
# op = max
# mapping = lambda f,x: f(x)
# composition = lambda f1, f2: f1 if f1 is not None else f2
ninf = (0,0,0) # (転倒数, #0, #1)
op = lambda x,y: (x[0]+y[0]+x[2]*y[1], x[1]+y[1], x[2]+y[2])
mapping = lambda f,x: ((x[1]+x[2])*(x[1]+x[2]-1)//2 - (x[1]*(x[1]-1)//2) - (x[2]*(x[2]-1)//2) - x[0], x[2], x[1]) if f else x
composition = lambda f1, f2: f1^f2
f0 = False
sg = LazySegmentTree(n, [((0,1,0) if item==0 else (0,0,1)) for item in a])
ans = []
for _ in range(q):
t = tuple(map(int, input().split()))
if t[0]==1:
_, l,r = t
sg.update(l-1,r,f=True)
else:
_,l,r = t
ans.append(sg.query(l-1,r)[0])
# break
write("\n".join(map(str, ans))) | p02569 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class LazySegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
# Find r s.t. calc(l, ..., r-1) = True and calc(l, ..., r) = False
def max_right(self, l, z):
if l >= self.n: return self.n
l += self.n
s = self.unitX
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.calc(l))):
while l < self.n:
l *= 2
if z(self.f(s, self.calc(l))):
s = self.f(s, self.calc(l))
l += 1
return l - self.n
s = self.f(s, self.calc(l))
l += 1
if l & -l == l: break
return self.n
# Find l s.t. calc(l, ..., r-1) = True and calc(l-1, ..., r-1) = False
def min_left(self, r, z):
if r <= 0: return 0
r += self.n
s = self.unitX
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.calc(r), s)):
while r < self.n:
r = r * 2 + 1
if z(self.f(self.calc(r), s)):
s = self.f(self.calc(r), s)
r -= 1
return r + 1 - self.n
s = self.f(self.calc(r), s)
if r & -r == r: break
return 0
def debug(self):
X = self.X
print(("X =", [self.calc(i) for i in range(self.n, self.n * 2)]))
f = lambda x, y: (x[0] + y[0] + x[2] * y[1], x[1] + y[1], x[2] + y[2])
g = lambda x, a, s: (x[1] * x[2] - x[0], x[2], x[1]) if a else x
h = lambda a, b: a ^ b
unitX = (0, 0, 0)
unitA = 0
N, Q = list(map(int, input().split()))
A = [(0, 1, 0) if int(a) == 0 else (0, 0, 1) for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
st.operate_range(l - 1, r, 1)
else:
print((st.getrange(l - 1, r)[0])) | import sys
input = lambda: sys.stdin.readline().rstrip()
class LazySegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
# Find r s.t. calc(l, ..., r-1) = True and calc(l, ..., r) = False
def max_right(self, l, z):
if l >= self.n: return self.n
l += self.n
s = self.unitX
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.calc(l))):
while l < self.n:
l *= 2
if z(self.f(s, self.calc(l))):
s = self.f(s, self.calc(l))
l += 1
return l - self.n
s = self.f(s, self.calc(l))
l += 1
if l & -l == l: break
return self.n
# Find l s.t. calc(l, ..., r-1) = True and calc(l-1, ..., r-1) = False
def min_left(self, r, z):
if r <= 0: return 0
r += self.n
s = self.unitX
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.calc(r), s)):
while r < self.n:
r = r * 2 + 1
if z(self.f(self.calc(r), s)):
s = self.f(self.calc(r), s)
r -= 1
return r + 1 - self.n
s = self.f(self.calc(r), s)
if r & -r == r: break
return 0
def debug(self):
X = self.X
print(("X =", [self.calc(i) for i in range(self.n, self.n * 2)]))
if False:
f = lambda x, y: (x[0] + y[0] + x[2] * y[1], x[1] + y[1], x[2] + y[2])
g = lambda x, a, s: (x[1] * x[2] - x[0], x[2], x[1]) if a else x
h = lambda a, b: a ^ b
unitX = (0, 0, 0)
unitA = 0
# (inversion, number of zeros, number of ones)
mm = 262143
def f(x, y):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
y0, y1, y2 = y >> 36, (y >> 18) & mm, y & mm
return (x0 + y0 + x2 * y1 << 36) + (x1 + y1 << 18) + (x2 + y2)
def g(x, a, s):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
return (x1 * x2 - x0 << 36) + (x2 << 18) + x1 if a else x
def h(a, b):
return a ^ b
unitX = 0
unitA = 0
N, Q = list(map(int, input().split()))
A = [(1 << 18) if int(a) == 0 else 1 for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
st.operate_range(l - 1, r, 1)
else:
print((st.getrange(l - 1, r) >> 36))
| p02569 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class LazySegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
# Find r s.t. calc(l, ..., r-1) = True and calc(l, ..., r) = False
def max_right(self, l, z):
if l >= self.n: return self.n
l += self.n
s = self.unitX
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.calc(l))):
while l < self.n:
l *= 2
if z(self.f(s, self.calc(l))):
s = self.f(s, self.calc(l))
l += 1
return l - self.n
s = self.f(s, self.calc(l))
l += 1
if l & -l == l: break
return self.n
# Find l s.t. calc(l, ..., r-1) = True and calc(l-1, ..., r-1) = False
def min_left(self, r, z):
if r <= 0: return 0
r += self.n
s = self.unitX
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.calc(r), s)):
while r < self.n:
r = r * 2 + 1
if z(self.f(self.calc(r), s)):
s = self.f(self.calc(r), s)
r -= 1
return r + 1 - self.n
s = self.f(self.calc(r), s)
if r & -r == r: break
return 0
def debug(self):
X = self.X
print(("X =", [self.calc(i) for i in range(self.n, self.n * 2)]))
if False:
f = lambda x, y: (x[0] + y[0] + x[2] * y[1], x[1] + y[1], x[2] + y[2])
g = lambda x, a, s: (x[1] * x[2] - x[0], x[2], x[1]) if a else x
h = lambda a, b: a ^ b
unitX = (0, 0, 0)
unitA = 0
# (inversion, number of zeros, number of ones)
mm = 262143
def f(x, y):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
y0, y1, y2 = y >> 36, (y >> 18) & mm, y & mm
return (x0 + y0 + x2 * y1 << 36) + (x1 + y1 << 18) + (x2 + y2)
def g(x, a, s):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
return (x1 * x2 - x0 << 36) + (x2 << 18) + x1 if a else x
def h(a, b):
return a ^ b
unitX = 0
unitA = 0
N, Q = list(map(int, input().split()))
A = [(1 << 18) if int(a) == 0 else 1 for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
st.operate_range(l - 1, r, 1)
else:
print((st.getrange(l - 1, r) >> 36))
| import sys
input = lambda: sys.stdin.readline().rstrip()
class LazySegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
# Find r s.t. calc(l, ..., r-1) = True and calc(l, ..., r) = False
def max_right(self, l, z):
if l >= self.n: return self.n
l += self.n
s = self.unitX
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.calc(l))):
while l < self.n:
l *= 2
if z(self.f(s, self.calc(l))):
s = self.f(s, self.calc(l))
l += 1
return l - self.n
s = self.f(s, self.calc(l))
l += 1
if l & -l == l: break
return self.n
# Find l s.t. calc(l, ..., r-1) = True and calc(l-1, ..., r-1) = False
def min_left(self, r, z):
if r <= 0: return 0
r += self.n
s = self.unitX
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.calc(r), s)):
while r < self.n:
r = r * 2 + 1
if z(self.f(self.calc(r), s)):
s = self.f(self.calc(r), s)
r -= 1
return r + 1 - self.n
s = self.f(self.calc(r), s)
if r & -r == r: break
return 0
def debug(self):
X = self.X
print(("X =", [self.calc(i) for i in range(self.n, self.n * 2)]))
if False:
f = lambda x, y: (x[0] + y[0] + x[2] * y[1], x[1] + y[1], x[2] + y[2])
g = lambda x, a, s: (x[1] * x[2] - x[0], x[2], x[1]) if a else x
h = lambda a, b: a ^ b
unitX = (0, 0, 0)
unitA = 0
# (inversion, number of zeros, number of ones)
mm = 262143
mmm = 68719214592
def f(x, y):
return x + y + ((x & mm) * (y & mmm) << 18)
def g(x, a, s):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
return (x1 * x2 - x0 << 36) + (x2 << 18) + x1 if a else x
def h(a, b):
return a ^ b
unitX = 0
unitA = 0
N, Q = list(map(int, input().split()))
A = [(1 << 18) if int(a) == 0 else 1 for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
st.operate_range(l - 1, r, 1)
else:
print((st.getrange(l - 1, r) >> 36))
| p02569 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class LazySegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
# Find r s.t. calc(l, ..., r-1) = True and calc(l, ..., r) = False
def max_right(self, l, z):
if l >= self.n: return self.n
l += self.n
s = self.unitX
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.calc(l))):
while l < self.n:
l *= 2
if z(self.f(s, self.calc(l))):
s = self.f(s, self.calc(l))
l += 1
return l - self.n
s = self.f(s, self.calc(l))
l += 1
if l & -l == l: break
return self.n
# Find l s.t. calc(l, ..., r-1) = True and calc(l-1, ..., r-1) = False
def min_left(self, r, z):
if r <= 0: return 0
r += self.n
s = self.unitX
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.calc(r), s)):
while r < self.n:
r = r * 2 + 1
if z(self.f(self.calc(r), s)):
s = self.f(self.calc(r), s)
r -= 1
return r + 1 - self.n
s = self.f(self.calc(r), s)
if r & -r == r: break
return 0
def debug(self):
X = self.X
print(("X =", [self.calc(i) for i in range(self.n, self.n * 2)]))
if False:
f = lambda x, y: (x[0] + y[0] + x[2] * y[1], x[1] + y[1], x[2] + y[2])
g = lambda x, a, s: (x[1] * x[2] - x[0], x[2], x[1]) if a else x
h = lambda a, b: a ^ b
unitX = (0, 0, 0)
unitA = 0
# (inversion, number of zeros, number of ones)
mm = 262143
mmm = 68719214592
def f(x, y):
return x + y + ((x & mm) * (y & mmm) << 18)
def g(x, a, s):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
return (x1 * x2 - x0 << 36) + (x2 << 18) + x1 if a else x
def h(a, b):
return a ^ b
unitX = 0
unitA = 0
N, Q = list(map(int, input().split()))
A = [(1 << 18) if int(a) == 0 else 1 for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
st.operate_range(l - 1, r, 1)
else:
print((st.getrange(l - 1, r) >> 36))
| import sys
input = lambda: sys.stdin.readline().rstrip()
class LazySegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
# Find r s.t. calc(l, ..., r-1) = True and calc(l, ..., r) = False
def max_right(self, l, z):
if l >= self.n: return self.n
l += self.n
s = self.unitX
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.calc(l))):
while l < self.n:
l *= 2
if z(self.f(s, self.calc(l))):
s = self.f(s, self.calc(l))
l += 1
return l - self.n
s = self.f(s, self.calc(l))
l += 1
if l & -l == l: break
return self.n
# Find l s.t. calc(l, ..., r-1) = True and calc(l-1, ..., r-1) = False
def min_left(self, r, z):
if r <= 0: return 0
r += self.n
s = self.unitX
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.calc(r), s)):
while r < self.n:
r = r * 2 + 1
if z(self.f(self.calc(r), s)):
s = self.f(self.calc(r), s)
r -= 1
return r + 1 - self.n
s = self.f(self.calc(r), s)
if r & -r == r: break
return 0
def debug(self):
X = self.X
print(("X =", [self.calc(i) for i in range(self.n, self.n * 2)]))
if False:
f = lambda x, y: (x[0] + y[0] + x[2] * y[1], x[1] + y[1], x[2] + y[2])
g = lambda x, a, s: (x[1] * x[2] - x[0], x[2], x[1]) if a else x
h = lambda a, b: a ^ b
unitX = (0, 0, 0)
unitA = 0
# (inversion, number of zeros, number of ones)
mm = (1 << 18) - 1
mmm = ((1 << 18) - 1) << 18
def f(x, y):
return x + y + ((x & mm) * (y & mmm) << 18)
def g(x, a, s):
x0, x1, x2 = x >> 36, (x >> 18) & mm, x & mm
return (x1 * x2 - x0 << 36) + (x2 << 18) + x1 if a else x
def h(a, b):
return a ^ b
unitX = 0
unitA = 0
N, Q = list(map(int, input().split()))
A = [(1 << 18) if int(a) == 0 else 1 for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
t, l, r = list(map(int, input().split()))
if t == 1:
st.operate_range(l - 1, r, 1)
else:
print((st.getrange(l - 1, r) >> 36))
| p02569 |
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
N,H,W = list(map(int,readline().split()))
RCA = [tuple(int(x) for x in line.split()) for line in readlines()]
RCA.sort(key = lambda x: -x[2])
RCA
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
| import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N,H,W = list(map(int,readline().split()))
RCA = [tuple(int(x) for x in line.split()) for line in readlines()]
RCA.sort(key = lambda x: -x[2])
RCA
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
| p02931 |
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N,H,W = list(map(int,readline().split()))
RCA = [tuple(int(x) for x in line.split()) for line in readlines()]
RCA.sort(key = lambda x: -x[2])
RCA
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
| import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
import operator
N,H,W = list(map(int,readline().split()))
RCA = [tuple(int(x) for x in line.split()) for line in readlines()]
RCA.sort(key = operator.itemgetter(2), reverse=True)
root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)
def find_root(x):
y = root[x]
if x == y:
return y
z = find_root(y)
root[x] = z
return z
def merge(x,y):
x,y = find_root(x),find_root(y)
sx,sy = size[x],size[y]
if sx < sy:
sx,sy = sy,sx
x,y = y,x
root[y] = x
no_cycle[x] = no_cycle[x] and no_cycle[y]
answer = 0
for R,C,A in RCA:
x,y = R-1,H+C-1
rx,ry = find_root(x),find_root(y)
if rx == ry:
if not no_cycle[rx]:
continue
no_cycle[rx] = False
else:
if (not no_cycle[rx]) and (not no_cycle[ry]):
continue
merge(rx,ry)
answer += A
print(answer)
| p02931 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def par(a):
if P[a] == a: return a
t = par(P[a])
P[a] = t
return t
def unite(a, b):
if par(a) != par(b): C[par(a)] += C[par(b)]
P[par(b)] = par(a)
N, H, W = list(map(int, input().split()))
P = [i for i in range(H+W)]
C = [1] * (H+W)
X = []
for _ in range(N):
r, c, a = list(map(int, input().split()))
X.append((a, r-1, c+H-1))
X = sorted(X)
ans = 0
while X:
a, r, c = X.pop()
unite(r, c)
if C[par(r)]:
ans += a
C[par(r)] -= 1
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def par(a):
if P[a] < 0: return a
t = par(P[a])
P[a] = t
return t
def unite(a, b):
if par(a) == par(b): return 0
C[par(a)], C[par(b)] = C[par(a)] + C[par(b)], C[par(a)] + C[par(b)]
if P[par(b)] == P[par(a)]:
P[par(b)] = par(a)
P[par(a)] -= 1
elif P[par(b)] > P[par(a)]:
P[par(b)] = par(a)
else:
P[par(a)] = par(b)
N, H, W = list(map(int, input().split()))
P = [-1 for i in range(H+W)]
C = [1] * (H+W)
X = []
for _ in range(N):
r, c, a = list(map(int, input().split()))
X.append((a, r-1, c+H-1))
X = sorted(X)
ans = 0
while X:
a, r, c = X.pop()
unite(r, c)
if C[par(r)]:
ans += a
C[par(r)] -= 1
print(ans) | p02931 |
n = int(eval(input()))
list_V = list(map(int, input().split()))
list_Vx = []
list_Vy = []
for i, s in enumerate(list_V):
if i % 2 == 0:
list_Vx.append(s)
else:
list_Vy.append(s)
list_Vx_Count = [0 for _ in range(pow(10, 5))]
list_Vy_Count = [0 for _ in range(pow(10, 5))]
for i in list_Vx:
list_Vx_Count[i-1] += 1
for i in list_Vy:
list_Vy_Count[i-1] += 1
ans = n - max(list_Vx_Count) - max(list_Vy_Count)
if list_Vx_Count.count(max(list_Vx_Count)) == 1 and list_Vy_Count.count(max(list_Vy_Count)):
if list_Vx_Count.index(max(list_Vx_Count)) == list_Vy_Count.index(max(list_Vy_Count)):
ans = n - max(max(list_Vx_Count)+sorted(list_Vx_Count)[-2], max(list_Vy_Count)+sorted(list_Vy_Count)[-2])
print(ans) | from collections import Counter
n = int(eval(input()))
list_A = list(map(int, input().split()))
L, R = [], []
for i in range(n):
if i % 2 == 0:
L.append(list_A[i])
else:
R.append(list_A[i])
A = Counter(L)
A = sorted(list(A.items()), key=lambda x:x[1], reverse=True)
A.append((-1, 0))
B = Counter(R)
B = sorted(list(B.items()), key=lambda x:x[1], reverse=True)
B.append((-1, 0))
if A[0][0] != B[0][0]:
print((n - A[0][1] - B[0][1]))
else:
print((min(n - A[1][1] - B[0][1], n - A[0][1] - B[1][1])))
| p03244 |
import collections
N = int(eval(input()))
even = collections.defaultdict(lambda: 0)
odd = collections.defaultdict(lambda: 0)
for i, a in enumerate(map(int, input().split())):
if i % 2 == 0:
even[a] += 1
else:
odd[a] += 1
if len(list(even.keys())) == 1 and len(list(odd.keys())) == 1 and list(even.keys())[0] == list(odd.keys())[0]:
print((N // 2))
else:
m = 0
for e_k, e_v in list(even.items()):
for o_k, o_v in list(odd.items()):
if e_k == o_k:
continue
m = max(m, e_v + o_v)
print((N - m))
| import collections
N = int(eval(input()))
even = collections.defaultdict(lambda: 0)
odd = collections.defaultdict(lambda: 0)
for i, a in enumerate(map(int, input().split())):
if i % 2 == 0:
even[a] += 1
else:
odd[a] += 1
if len(list(even.keys())) == 1 and len(list(odd.keys())) == 1 and list(even.keys())[0] == list(odd.keys())[0]:
print((N // 2))
else:
m = 0
for e_k, e_v in sorted(list(even.items()), key=lambda x: x[1], reverse=True)[:2]:
for o_k, o_v in sorted(list(odd.items()), key=lambda x: x[1], reverse=True)[:2]:
if e_k == o_k:
continue
m = max(m, e_v + o_v)
print((N - m))
| p03244 |
import collections
N = int(eval(input()))
VV = list(map(int, input().split()))
v_even = VV[::2]
v_odd = VV[1::2]
e = collections.Counter(v_even)
o = collections.Counter(v_odd)
e_common = e.most_common()
o_common = o.most_common()
if (e_common[0] != o_common[0]):
tmp = e_common[0][1] + o_common[0][1]
answer = N - tmp
elif (len(e_common) == 1 or len(o_common) == 1): # case one type
if (len(e_common) == 1 and len(o_common) == 1):
answer = N // 2
elif (len(e_common) == 1):
answer = N // 2 - o_common[1][1]
elif (len(o_common) == 1):
answer = N // 2 - e_common[1][1]
else:
tmp1 = e_common[0][1] + o_common[1][1]
tmp2 = e_common[1][1] + o_common[0][1]
tmp = max(tmp1, tmp2)
answer = N - tmp
print(answer) | import collections
N = int(eval(input()))
VV = list(map(int, input().split()))
v_even = VV[::2]
v_odd = VV[1::2]
e = collections.Counter(v_even).most_common() + [(0, 0)]
o = collections.Counter(v_odd).most_common() + [(0, 0)]
if (e[0][0] == o[0][0]):
tmp1 = e[0][1] + o[1][1]
tmp2 = e[1][1] + o[0][1]
answer = N - max(tmp1, tmp2)
else:
tmp = e[0][1] + o[0][1]
answer = N - tmp
print(answer) | p03244 |
import collections
n = int(eval(input()))
v = list(map(int, input().split()))
v1 = [v[i*2+1] for i in range(n//2)]
v2 = [v[i*2] for i in range(n//2)]
c1 = collections.Counter(v1).most_common()
c2 = collections.Counter(v2).most_common()
if len(set(v1)) == len(set(v2)) == 1:
if c1[0][0] != c2[0][0]:
print((0))
else:
print((min(len(v1), len(v2))))
elif len(set(v1))==1:
if c1[0][0] != c2[0][0]:
print((sum([i[1] for i in c2])-c2[0][1]))
else:
print((sum([i[1] for i in c2])-c2[1][1]))
elif len(set(v2))==1:
if c1[0][0] != c2[0][0]:
print((sum([i[1] for i in c1])-c1[0][1]))
else:
print((sum([i[1] for i in c1])-c1[1][1]))
else:
if c1[0][0] != c2[0][0]:
print(((sum([i[1] for i in c1])-c1[0][1]) + (sum([i[1] for i in c2])-c2[0][1])))
else:
print((min((sum([i[1] for i in c1])-c1[0][1])+(sum([i[1] for i in c2])-c2[1][1]),
(sum([i[1] for i in c1])-c1[1][1])+(sum([i[1] for i in c2])-c2[0][1])))) | import collections
n = int(eval(input()))
v = list(map(int, input().split()))
v1 = v[::2]
v2 = v[1::2]
c1 = collections.Counter(v1).most_common()
c2 = collections.Counter(v2).most_common()
if c1[0][0] != c2[0][0]:
print((len(v1)-c1[0][1] + len(v2)-c2[0][1]))
else:
if len(c1) == len(c2) == 1:
print((n // 2))
elif len(c1) == 1:
print((len(v2)-c2[1][1]))
elif len(c2) == 1:
print((len(v1)-c1[1][1]))
else:
print((min(len(v1)-c1[0][1]+len(v2)-c2[1][1], len(v1)-c1[1][1]+len(v2)-c2[0][1]))) | p03244 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.