input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
readline = sys.stdin.readline
N = int(readline())
T, A = list(map(int,readline().split()))
import math
for i in range(N - 1):
t,a = list(map(int,readline().split()))
i = 1
while True:
if t * i >= T and a * i >= A:
T,A = t * i,a * i
break
i += 1
print((T + A)) | import sys
readline = sys.stdin.readline
N = int(readline())
T, A = list(map(int,readline().split()))
for i in range(N - 1):
t,a = list(map(int,readline().split()))
# newT % t == 0 , newA % a == 0である
# newT >= T , newA >= Aである
# T以上の、tの倍数の最小値 = T / tの切り上げ
minT = ((T + t - 1) // t) * t
minA = minT * a // t
if minA >= A:
T,A = minT,minA
continue
minA = ((A + a - 1) // a) * a
minT = minA * t // a
T,A = minT,minA
print((T + A)) | p03966 |
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return((a*b)//gcd(a,b))
def main():
n=int(eval(input()))
a=1
b=1
for _ in range(n):
x,y = list(map(int,input().split()))
x1=x
y1=y
while x1<a or y1<b:
x1+=x
y1+=y
a=x1
b=y1
print((a+b))
if __name__ == "__main__":
main()
| def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return((a*b)//gcd(a,b))
def main():
n=int(eval(input()))
a=1
b=1
for _ in range(n):
x,y = list(map(int,input().split()))
n=a//x
m=b//y
if a%x!=0:
n+=1
if b%y!=0:
m+=1
a=max(n,m)*x
b=max(n,m)*y
print((a+b))
if __name__ == "__main__":
main()
| p03966 |
n=int(eval(input()))
from math import gcd
a,b=list(map(int,input().split()))
temp=a+b
for i in range(1,n):
c,d=list(map(int,input().split()))
i=c+d
j=i
c1=c
d1=d
while i<temp or c<a or d<b:
i+=j
c+=c1
d+=d1
temp=i
a=c
b=d
print(temp) | n=int(eval(input()))
from math import gcd
a,b=list(map(int,input().split()))
temp=a+b
for i in range(1,n):
c,d=list(map(int,input().split()))
j=c+d
x=max(a-c,0)//c
if max(a-c,0)%c!=0:
x+=1
y=max(b-d,0)//d
if max(b-d,0)%d!=0:
y+=1
z=max(temp-j,0)//j
if max(temp-j,0)%j!=0:
z+=1
l=[x,y,z]
temp=max(l)*j+j
a=max(l)*c+c
b=max(l)*d+d
print(temp) | p03966 |
N=int(eval(input()))
T=[]
A=[]
for i in range(N):
t,a=list(map(int,input().split()))
T.append(t)
A.append(a)
Tnow=T[0]
Anow=A[0]
ans=Tnow+Anow
for i in range(1,N):
t=T[i]
a=A[i]
tempans=(t+a+ans-1)//(t+a)*(t+a)
while True:
tempT=tempans*t//(t+a)
tempA=tempans*a//(t+a)
if tempT>=Tnow and tempA>=Anow:
ans=tempans
Tnow=tempT
Anow=tempA
break
else:
tempans+=t+a
print(ans)
| N=int(eval(input()))
T=[]
A=[]
for i in range(N):
t,a=list(map(int,input().split()))
T.append(t)
A.append(a)
Tnow=T[0]
Anow=A[0]
for i in range(1,N):
t=T[i]
a=A[i]
t1=(Tnow+t-1)//t*t
a1=t1//t*a
a2=(Anow+a-1)//a*a
t2=a2//a*t
if a1<Anow:
Tnow=t2
Anow=a2
elif t2<Tnow:
Tnow=t1
Anow=a1
elif t1+a1<=t2+a2:
Tnow=t1
Anow=a1
else:
Tnow=t2
Anow=a2
print((Tnow+Anow))
| p03966 |
#! /usr/bin/env python3
def f(a, b, c, d):
n = 1
while a > c * n or b > d * n : n += 1
return c * n, d * n
def main():
a, b = 0, 0
for i in range(int(eval(input()))):
c, d = list(map(int, input().split()))
a, b = f(a, b, c, d)
print((a+b))
if __name__ == '__main__':
main() | #! /usr/bin/env python3
def f(a, b, c, d):
n = max(1,a//c, b//d)
while a > c * n or b > d * n : n += 1
return c * n, d * n
def main():
a, b = 0, 0
for i in range(int(eval(input()))):
c, d = list(map(int, input().split()))
a, b = f(a, b, c, d)
print((a+b))
if __name__ == '__main__':
main()
| p03966 |
N = int(eval(input()))
L = []
for i in range(N):
L.append(tuple(map(int, input().split())))
nowT = L[0][0]
nowA = L[0][1]
for i in range(1, N):
tmpT = L[i][0]
tmpA = L[i][1]
mul = 2
while not(tmpT >= nowT and tmpA >= nowA):
tmpT = L[i][0] * mul
tmpA = L[i][1] * mul
mul += 1
nowT = tmpT
nowA = tmpA
print((nowT + nowA))
| N = int(eval(input()))
nowT = 1
nowA = 1
for i in range(N):
nextT, nextA = list(map(int, input().split()))
# mul = max(ceil(nowT / nextT), ceil(nowA / nextA))
mul = max(-(-nowT // nextT), -(-nowA // nextA))
nowT = nextT * mul
nowA = nextA * mul
print((nowT + nowA))
| p03966 |
N = int(eval(input()))
P = [0,0]
for i in range(N):
Q = list(map(int,input().split()))
t = Q[0]
a = Q[1]
m = 1
while True:
t = Q[0] * m
a = Q[1] * m
if t >= P[0] and a >= P[1]:
P[0] = t
P[1] = a
break
m += 1
print((sum(P))) | N = int(eval(input()))
P = [1,1]
for i in range(N):
Q = list(map(int,input().split()))
t = Q[0]
a = Q[1]
m = max(P[0]//t,P[1]//a,1)
while True:
t = Q[0] * m
a = Q[1] * m
if t >= P[0] and a >= P[1]:
P[0] = t
P[1] = a
break
m += 1
print((sum(P))) | p03966 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
def run():
N, *A = list(map(int, read().split()))
dic = defaultdict(lambda:0)
for a in A:
dic[a] += 1
G = {}
for key in sorted(list(dic.keys())):
G[N] = key
N -= dic[key]
criteria = 0
for key in list(G.keys()):
for _ in range(G[key]):
criteria ^= key
if not criteria:
print('second')
else:
print('first')
if __name__ == "__main__":
run()
| # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
def run():
N, *A = list(map(int, read().split()))
dic = defaultdict(lambda:0)
for a in A:
dic[a] += 1
G = {}
for key in sorted(list(dic.keys())):
G[N] = key
N -= dic[key]
criteria = 0
for key in list(G.keys()):
if G[key] % 2:
criteria ^= key
if not criteria:
print('second')
else:
print('first')
if __name__ == "__main__":
run()
| p03197 |
import sys
input = sys.stdin.readline
from collections import *
def dfs(x, y):
if x==0 and y==0:
t[x][y] = False
return False
if x>=1:
t[x][y] |= not dfs(x-1, y)
if y>=1:
t[x][y] |= not dfs(x, y-1)
if min(x, y)>=1:
t[x][y] |= not dfs(x-1, y-1)
return t[x][y]
t = [[False]*7 for _ in range(7)]
for i in range(7):
for j in range(7):
dfs(i, j)
"""
for ti in t:
print(*ti)
"""
N = int(eval(input()))
flag = True
for _ in range(N):
a = int(eval(input()))
if a%2==1:
flag = False
if flag:
print('second')
else:
print('first') | import sys
input = sys.stdin.readline
"""
def dfs(x, y):
if x==0 and y==0:
return False
res = False
if x>0:
res |= not dfs(x-1, y)
if y>0:
res |= not dfs(x, y-1)
if min(x, y)>0:
res |= not dfs(x-1, y-1)
return res
t = [[False]*5 for _ in range(5)]
for i in range(5):
for j in range(5):
t[i][j] = dfs(i, j)
for ti in t:
print(*ti)
"""
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
for ai in a:
if ai%2==1:
print('first')
exit()
print('second') | p03197 |
n = int(eval(input()))
for i in range(n):
a = int(eval(input()))
if a%2 == 1:
print('first')
exit()
else:
print('second')
| n = int(eval(input()))
A = [int(eval(input())) for _ in range(n)]
for a in A:
if a != 1:
break
else:
print('first')
exit()
cnt = 0
for a in A:
if a%2 == 0:
cnt += 1
if cnt == n:
print('second')
else:
print('first')
| p03197 |
n=int(eval(input()))
ans="second"
for i in range(n):
if int(eval(input()))%2:ans="first"
print(ans) | n=int(eval(input()))
a=[int(eval(input()))%2 for _ in range(n)]
if 1 in a:print("first")
else:print("second") | p03197 |
print(("second" if all(int(eval(input()))%2 == 0 for i in range(int(eval(input())))) else 'first'))
| import sys
print(('second' if all(i%2==0 for i in list(map(int,sys.stdin))[1:]) else 'first')) | p03197 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
if all(a % 2 == 0 for a in A):
print("second")
else:
print("first")
| def main() -> None:
N = int(eval(input()))
P = [int(eval(input())) for _ in range(N)]
print(("first" if any(x % 2 == 1 for x in P) else "second"))
if __name__ == '__main__':
main()
| p03197 |
import collections
N = int(eval(input()))
a = [0] * N
for i in range(N):
a[i] = int(eval(input()))
def solve():
return any(x % 2 == 1 for x in a)
print(('first' if solve() else 'second'))
| _,*a=open(0);print(('first' if any(int(x)%2 for x in a)else'second')) | p03197 |
'''input
3
1
30000
20000
'''
import time
import math
n = int(eval(input()))
print(("second" if all([int(eval(input())) % 2 == 0 for i in range(n)]) else "first"))
| print(("second" if all([int(eval(input())) % 2 == 0 for i in range(int(eval(input())))]) else "first"))
| p03197 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
cnt = 0
for i in range(N):
if A[i]%2==1:
cnt += 1
if cnt>0:
print("first")
else:
print("second") | N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
flag = 0
for i in range(N):
if A[i]%2==1:
flag = 1
break
if flag==1:
print("first")
else:
print("second") | p03197 |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N = int(input())
A = (int(input()) for _ in range(N))
print("second") if all(( a%2==0 for a in A)) else print("first")
if __name__ == "__main__":
main()
| import sys
def input(): return sys.stdin.readline().strip()
def main():
N = int(input())
A = [int(input()) for _ in range(N)]
print("second") if all(( a%2==0 for a in A)) else print("first")
if __name__ == "__main__":
main()
| p03197 |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N = int(input())
A = [int(input()) for _ in range(N)]
print("second") if all(( a%2==0 for a in A)) else print("first")
if __name__ == "__main__":
main()
| import sys
def input(): return sys.stdin.readline().strip()
def main():
N = int(input())
A = [int(input()) for _ in range(N)]
print("first") if any([a%2 for a in A]) else print("second")
if __name__ == "__main__":
main()
| p03197 |
def main():
n = int(eval(input()))
ans =0
f=0
for i in range(0 , n):
t = int(eval(input()))
if t%2!=0:
f=1
if f==1:
print("first")
else:
print("second")
if __name__=="__main__":
main() | # if any tree contains an odd no of table then first is the winner
# First strategy is to make a tree with odd no of apples
# second strategy is to make a tree with even no of apples
# if the tree doesn't contain any odd apples when first takes an apples he will make it odd
# second would try to make it even by taking one apple from that tree
def main():
n = int(eval(input()))
ans =0
f=0
for i in range(0 , n):
t = int(eval(input()))
if t%2!=0:
f=1
if f==1:
print("first")
else:
print("second")
if __name__=="__main__":
main() | p03197 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n=I()
l=[I() for _ in range(n)]
for x in l:
if x%2==1:
return 'first'
return 'second'
# main()
print((main()))
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
# 最後に食べたら勝ち
# 1を引けば勝ち
# 奇数調整をする
# 相手に全て偶数を与えるよう調整する
# all偶数だと負け
n=I()
f=False
for _ in range(n):
if I()%2==1:
f=True
if f:
return 'first'
return 'second'
# main()
print((main()))
| p03197 |
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
# 最後に食べたら勝ち
# 1を引けば勝ち
# 奇数調整をする
# 相手に全て偶数を与えるよう調整する
# all偶数だと負け
n=I()
f=False
for _ in range(n):
if I()%2==1:
f=True
if f:
return 'first'
return 'second'
# main()
print((main()))
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
N=I()
a=[I() for _ in range(N)]
for x in a:
if x%2!=0:
return 'first'
return 'second'
# main()
print((main()))
| p03197 |
import sys
read = sys.stdin.read
N, *a = list(map(int, read().split()))
a = [i % 2 for i in a]
if 1 in a:
print('first')
else:
print('second')
| import sys
read = sys.stdin.read
N, *a = list(map(int, read().split()))
a = [i for i in a if i % 2 == 1]
if len(a) > 0:
print('first')
else:
print('second')
| p03197 |
N=int(input())
P=list(map(int, input().split()))
X=[0]+list(map(int, input().split()))
ko=[[] for _ in range(N+1)]
for i, p in enumerate(P, 2):
ko[p].append(i)
def f(p):
n=len(ko[p])
if n==0:
return X[p], 0
dp=[[float('inf')]*5001 for _ in range(n+1)]
dp[0][0]=0
for i, c in enumerate(ko[p], 1):
a, b=f(c)
for j in range(a, 5001):
dp[i][j]=min(dp[i][j], dp[i-1][j-a]+b)
for j in range(b, 5001):
dp[i][j]=min(dp[i][j], dp[i-1][j-b]+a)
out=min(dp[-1][:X[p]+1])
if out==float('inf'):
print('IMPOSSIBLE')
exit()
elif out>X[p]:
return out, X[p]
else:
return X[p], out
print('POSSIBLE') if min(f(1))<=X[1] else print('IMPOSSIBLE')
| N=int(input())
P=list(map(int, input().split()))
X=[0]+list(map(int, input().split()))
ko=[[] for _ in range(N+1)]
for i, p in enumerate(P, 2):
ko[p].append(i)
def f(p):
n=len(ko[p])
if n==0:
return X[p], 0
dp=[[float('inf')]*(X[p]+1) for _ in range(n+1)]
dp[0][0]=0
for i, c in enumerate(ko[p], 1):
a, b=f(c)
for j in range(a, X[p]+1):
dp[i][j]=min(dp[i][j], dp[i-1][j-a]+b)
for j in range(b, X[p]+1):
dp[i][j]=min(dp[i][j], dp[i-1][j-b]+a)
out=min(dp[-1])
if out==float('inf'):
print('IMPOSSIBLE')
exit()
elif out>X[p]:
return out, X[p]
else:
return X[p], out
print('POSSIBLE') if min(f(1))<=X[1] else print('IMPOSSIBLE')
| p03603 |
from itertools import product
n = int(eval(input()))
P = [0, 0] + [int(i) for i in input().split()]
X = [0] + [int(i) for i in input().split()]
C = [[] for i in range (n+1)]
for i, p in enumerate(P):
C[p].append(i)
def dfs(i):
if not C[i]:
return X[i], 0
A = []
for c in C[i]:
A.append(dfs(c))
S = 0
for a in A:
S += sum(a)
B = []
for bits in range(2**(len(A))):
a = 0
for j, c in enumerate(A):
a += c[bits >> j & 1]
if a > X[i]:
break
if a <= X[i]:
B.append(a)
if not B:
print('IMPOSSIBLE')
exit()
return X[i], S - max(B)
dfs(1)
print('POSSIBLE') | from itertools import product
n = int(eval(input()))
P = [0, 0] + [int(i) for i in input().split()]
X = [0] + [int(i) for i in input().split()]
C = [[] for i in range (n+1)]
for i, p in enumerate(P):
C[p].append(i)
def dfs(i):
if not C[i]:
return X[i], 0
A = []
for c in C[i]:
A.append(dfs(c))
S = 0
for a in A:
S += sum(a)
dp = [[False]*(X[i]+1) for j in range(len(A)+1)]
dp[0][0] = True
for j in range(len(A)):
for k in range(X[i]+1):
a, b = A[j]
if a <= k and dp[j][k-a]:
dp[j+1][k] = True
elif b <= k and dp[j][k-b]:
dp[j+1][k] = True
if not any(dp[j+1]):
print('IMPOSSIBLE')
exit()
b = 0
for j in range(X[i], -1, -1):
if dp[len(A)][j]:
b = j
break
return X[i], S - b
dfs(1)
print('POSSIBLE') | p03603 |
#copy for experience
import sys
sys.setrecursionlimit(10**8)
N=int(eval(input()))
P=[int(i) for i in input().split()]
X=[int(i) for i in input().split()]
table=[[] for i in range(N)]
for i in range(N-1):
table[P[i]-1].append(i+1)
dp=[0]*N #shiro
def tree(pa):
for i in table[pa]:
tree(i)
t=len(table[pa])
if t==0:
return
T=set()
s=0
for i in range(t):
x=table[pa][i]
s+=X[x]+dp[x]
if i==0:
if X[x]<=X[pa]:
T.add(X[x])
if dp[x]<=X[pa]:
T.add(dp[x])
continue
S=set()
for k in T:
if k+X[x]<=X[pa]:
S.add(k+X[x])
if k+dp[x]<=X[pa]:
S.add(k+dp[x])
T=S
if len(T)==0:
print('IMPOSSIBLE')
sys.exit()
dp[pa]=s-max(T)
return
tree(0)
print('POSSIBLE')
| #copy for experience
# E
N = int(eval(input()))
P_list = list(map(int, input().split()))
X_list = list(map(int, input().split()))
# graph
child_list = [[] for _ in range(N+1)]
for i in range(2, N+1):
child_list[P_list[i-2]].append(i)
# from root
# minimize local total weight
color1 = [0]+X_list
color2 = [0]*(N+1)
# solve knapsack
def solve_knapsack(L, M):
min_acc = sum([min(color1[j], color2[j]) for j in L])
if min_acc > M:
return -1
else:
add_can = M - min_acc
add_set = set([0])
for j in L:
add_j = max(color1[j], color2[j]) - min(color1[j], color2[j])
add_set_ = set(add_set)
for s in add_set:
if s + add_j <= add_can:
add_set_.add(s + add_j)
add_set = add_set_
total = sum([color1[j]+color2[j] for j in L])
return total - max(add_set) - min_acc
res = "POSSIBLE"
for i in range(N, 0, -1):
if len(child_list[i]) == 0:
pass
elif len(child_list[i]) == 1:
j = child_list[i][0]
if min(color1[j], color2[j]) > X_list[i-1]:
res = "IMPOSSIBLE"
break
elif max(color1[j], color2[j]) > X_list[i-1]:
color2[i] = max(color1[j], color2[j])
else:
color2[i] = min(color1[j], color2[j])
else:
c2 = solve_knapsack(child_list[i], X_list[i-1])
if c2 < 0:
res = "IMPOSSIBLE"
break
else:
color2[i] = c2
print(res)
| p03603 |
while True:
n, r = list(map(int, input().split()))
if not n:
break
sheets = sorted(tuple(map(int, input().split())) for _ in range(n))
table = [[0, 0, 0] for _ in range(10001)]
for x1, y1, x2, y2 in sheets:
for y in range(y1, y2):
t = table[y]
rx = t[1]
if not rx or rx < x1:
t[0] += x2 - x1
t[1] = x2
t[2] += 2
elif rx < x2:
t[0] += x2 - rx
t[1] = x2
print((sum(t[0] for t in table)))
if r == 1:
continue
around = 0
prev_w = 0
for y, (w, rx, e) in enumerate(table):
around += abs(w - prev_w) + (e if w else 0)
prev_w = w
around += prev_w
print(around) | while True:
n, r = list(map(int, input().split()))
if not n:
break
sheets = sorted(tuple(map(int, input().split())) for _ in range(n))
table_c = [0] * 10001
table_r = [0] * 10001
table_e = [0] * 10001
for x1, y1, x2, y2 in sheets:
for y in range(y1, y2):
rx = table_r[y]
if rx < x1 or not rx:
table_c[y] += x2 - x1
table_r[y] = x2
table_e[y] += 2
elif rx < x2:
table_c[y] += x2 - rx
table_r[y] = x2
print((sum(table_c)))
if r == 1:
continue
around = 0
prev_w = 0
for y, w in enumerate(table_c):
around += abs(w - prev_w) + (table_e[y] if w else 0)
prev_w = w
around += prev_w
print(around) | p00432 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0041
"""
import sys
from itertools import permutations, product
def has_possibility(digits):
"""
??°????????????????????????10?????????????????§??????????????????????????????
??°????????§?????????????????????????????????????????????????????????????????°??????0 or 1?????´??????????????????????????????
????????????????????§??????????????????????????§???????????§???10????????§????????°???????????£??????10?????????????????????
"""
result = False
digits.sort(reverse=True)
total = digits[0]
for i in digits[1:]:
if i < 2:
total += i
else:
total *= i
if total >= 10:
result = True
return result
def make_ten(digits):
result = '0'
for a, b, c, d in permutations(digits, 4):
if result != '0':
break
for op1, op2, op3 in product(['+', '-', '*'], repeat=3):
# 1, 2, 3
exp = '((({} {} {}) {} {}) {} {})'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 1, 3, 2
exp= '(({} {} {}) {} ({} {} {}))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 2, 1, 3
exp = '(({} {} ({} {} {})) {} {})'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 3, 1, 2
exp = '({} {} (({} {} {}) {} {}))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 3, 2, 1
exp = '({} {} ({} {} ({} {} {})))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 2, 3, 1
exp = '(({} {} {}) {} ({} {} {}))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
return result
def do_calc(x, y, op):
result = None
if op == '+':
result = x + y
elif op == '-':
result = x - y
elif op == '*':
result = x * y
return result
# ????????°????????????????????????10?????????????????????????????¢?????°????????§?????????????????????????????°??????????????¨???????????????????????¨??????????´????????????????
Memo = {}
def solve(digits):
global Memo
digits.sort(reverse=True)
data = ''.join(map(str, digits))
if data in Memo:
pass
else:
Memo[data] = make_ten(digits)
return Memo[data]
def main(args):
while True:
digits = [int(x) for x in input().strip().split(' ')]
# digits = [int(x) for x in '{:04d}'.format(count)]
if digits[0] == 0 and digits[1] == 0 and digits[2] == 0 and digits[3] == 0:
break
result = solve(digits)
print(result)
#print('count={}, {}'.format(count, result))
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0041
"""
import sys
from itertools import permutations, product
def make_ten(digits):
result = '0'
for a, b, c, d in permutations(digits, 4):
if result != '0':
break
for op1, op2, op3 in product(['+', '-', '*'], repeat=3):
# 1, 2, 3
exp = '((({} {} {}) {} {}) {} {})'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 1, 3, 2
exp= '(({} {} {}) {} ({} {} {}))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 2, 1, 3
exp = '(({} {} ({} {} {})) {} {})'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 3, 1, 2
exp = '({} {} (({} {} {}) {} {}))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 3, 2, 1
exp = '({} {} ({} {} ({} {} {})))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
# 2, 3, 1
exp = '(({} {} {}) {} ({} {} {}))'.format(a, op1, b, op2, c, op3, d)
if eval(exp) == 10:
result = exp
break
return result
# ????????°????????????????????????10?????????????????????????????¢?????°????????§?????????????????????????????°??????????????¨???????????????????????¨??????????´????????????????
Memo = {}
def solve(digits):
global Memo
digits.sort(reverse=True)
data = ''.join(map(str, digits))
if data in Memo:
pass
else:
Memo[data] = make_ten(digits)
return Memo[data]
def main(args):
while True:
digits = [int(x) for x in input().strip().split(' ')]
# digits = [int(x) for x in '{:04d}'.format(count)]
if digits[0] == 0 and digits[1] == 0 and digits[2] == 0 and digits[3] == 0:
break
result = solve(digits)
print(result)
#print('count={}, {}'.format(count, result))
if __name__ == '__main__':
main(sys.argv[1:]) | p00041 |
M, N = list(map(int, input().split()))
K = eval(input())
D = {}
for i in range(M+1):
D[i, 0] = 0, 0
for j in range(N+1):
D[0, j] = 0, 0
for i in range(1, M+1):
a = input()
for j in range(1, N+1):
if a[j-1] == 'J':
D[i, j] = (D[i-1, j][0] + D[i, j-1][0] - D[i-1, j-1][0] + 1,
D[i-1, j][1] + D[i, j-1][1] - D[i-1, j-1][1])
elif a[j-1] == 'O':
D[i, j] = (D[i-1, j][0] + D[i, j-1][0] - D[i-1, j-1][0],
D[i-1, j][1] + D[i, j-1][1] - D[i-1, j-1][1] + 1)
else:
D[i, j] = (D[i-1, j][0] + D[i, j-1][0] - D[i-1, j-1][0],
D[i-1, j][1] + D[i, j-1][1] - D[i-1, j-1][1])
for _ in range(K):
b0, b1, b2, b3 = list(map(int, input().split()))
nJ = D[b2, b3][0]-D[b0-1, b3][0]-D[b2, b1-1][0]+D[b0-1, b1-1][0]
nO = D[b2, b3][1]-D[b0-1, b3][1]-D[b2, b1-1][1]+D[b0-1, b1-1][1]
nI = (b2-b0+1)*(b3-b1+1)-nJ-nO
print(nJ, nO, nI) | from array import array
M, N = list(map(int, input().split()))
K = eval(input())
D0 = [array('l', [0]) * (N+1) for _ in range(M+1)]
D1 = [array('l', [0]) * (N+1) for _ in range(M+1)]
for i in range(1, M+1):
a = input()
for j in range(1, N+1):
D0[i][j] = D0[i-1][j] + D0[i][j-1] - D0[i-1][j-1] + (a[j-1] == 'J')
D1[i][j] = D1[i-1][j] + D1[i][j-1] - D1[i-1][j-1] + (a[j-1] == 'O')
for _ in range(K):
b0, b1, b2, b3 = list(map(int, input().split()))
nJ = D0[b2][b3]-D0[b0-1][b3]-D0[b2][b1-1]+D0[b0-1][b1-1]
nO = D1[b2][b3]-D1[b0-1][b3]-D1[b2][b1-1]+D1[b0-1][b1-1]
nI = (b2-b0+1)*(b3-b1+1)-nJ-nO
print(nJ, nO, nI) | p00483 |
n = eval(input())
code = input().split()
# DP(N, <parentheses nested>)
dp = [[0]*3 for i in range(n)]
dp[0] = [int(code[0]), -10**18, -10**18]
for i in range(1,n):
op, a = code[2*i-1: 2*i+1]
v = int(a)
if op is "+":
dp[i][0] = max(dp[i-1][0]+v, dp[i-1][1]-v, dp[i-1][2]+v)
dp[i][1] = max( dp[i-1][1]-v, dp[i-1][2]+v)
dp[i][2] = dp[i-1][2]+v
else:
dp[i][0] = max(dp[i-1][0]-v, dp[i-1][1]+v, dp[i-1][2]-v)
dp[i][1] = max(dp[i-1][0]-v, dp[i-1][1]+v, dp[i-1][2]-v)
dp[i][2] = max( dp[i-1][1]+v, dp[i-1][2]-v)
print(max(dp[-1])) | n = eval(input())
code = input().split()
# DP(N, <parentheses nested>)
a = int(code[0]); b = c = -10**18
for op, v in zip(code[1::2], list(map(int,code[2::2]))):
if op is "+":
d = max(b-v, c+v)
a,b,c = max(a+v, d), d, c+v
else:
d = max(b+v, c-v)
a,b,c = max(a-v, d), max(a-v, d), d
print(max(a, b, c)) | p03850 |
import itertools
while True:
N = int(eval(input()))
if not N:
break
D = [[] for _ in range(30)]
for i in range(N):
for x in map(int, input().split()[1:]):
D[x - 1].append(i)
C = [1 << i for i in range(N)]
for d in range(30):
for i, j in itertools.permutations(D[d], 2):
C[i] = C[i] | C[j]
if any(x == (1 << N) - 1 for x in C):
print((d + 1))
break
else:
print((-1)) | import itertools
while True:
N = int(eval(input()))
if not N:
break
D = [[] for _ in range(30)]
for i in range(N):
for x in map(int, input().split()[1:]):
D[x - 1].append(i)
C = [1 << i for i in range(N)]
for d in range(30):
for i, j in itertools.combinations(D[d], 2):
C[i] = C[j] = C[i] | C[j]
if any(x == (1 << N) - 1 for x in C):
print((d + 1))
break
else:
print((-1)) | p01136 |
MAX_N = 50
MAX_DAY = 30
def solve(n, f):
dp = [[set() for j in range(n)] for i in range(MAX_DAY + 1)]
for i in range(n):
dp[0][i].add(i)
for d in range(1, MAX_DAY + 1):
# for line in dp[:5]:
# print(line)
for i in range(n):
dp[d][i] |= dp[d - 1][i]
for j in range(n):
if f[d][i] and f[d][j]:
dp[d][i] |= dp[d - 1][j]
if len(dp[d][i]) == n:
return d
return -1
######################################
while True:
n = int(eval(input()))
if n == 0:
exit()
f = [[False] * n for i in range(MAX_DAY + 1)]
for i in range(n):
_, *li = list(map(int, input().split()))
for x in li:
f[x][i] = True
# for line in f:
# print(line)
print((solve(n, f))) | MAX_N = 50
MAX_DAY = 30
def solve(n, f):
dp = [{i} for i in range(n)]
for d in range(1, MAX_DAY + 1):
for i in range(n):
for j in range(n):
if f[d][i] and f[d][j]:
dp[i] |= dp[j]
if len(dp[i]) == n:
return d
return -1
######################################
while True:
n = int(eval(input()))
if n == 0:
exit()
f = [[False] * n for i in range(MAX_DAY + 1)]
for i in range(n):
_, *li = list(map(int, input().split()))
for x in li:
f[x][i] = True
print((solve(n, f))) | p01136 |
"""
遅延評価セグメント木
op(s, t)：二項演算の関数（実際に評価する値同士の演算）：現在の値の中での比較
composition(f, g)：二項演算の関数（遅延評価する値同士の演算）：どちらの値を遅延伝播するか決定
mapping(f, a)：二項演算の関数（二つの集合についての演算（ただし、X・Mの順））：現在の値と遅延評価により生じた値のどちらを採用するかを決定
rangeop(f, length)：範囲が関係してくるときに行う演算
e()：実際に評価する値の単位元
id()：遅延評価する値の単位元
update, find, bisect, 全てにおいて, 1-indexとなっている。
(大抵の場合、Atcoderの問題文の表記のままの値を、メソッドに代入すれば良い)
"""
import sys
input = sys.stdin.readline
class LazySegmentTree:
#遅延評価セグメント木
def __init__(s, op, e, mapping, composition, rangeop, 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.rangeop = rangeop
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)
def get_length(s, i):
return pow(2, (s.size).bit_length() - (i).bit_length())
# 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(s.rangeop(f, s.get_length(k)), 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
mod = 998244353
lim = 1 << 32
def func1(x, y):
return (x + y) % mod
def func2(a2, a1):
return (((a1 >> 32) * (a2 >> 32) % mod) << 32) + (((a1 % lim) * (a2 >> 32) + (a2 % lim)) % mod)
def func3(a, x):
return ((a >> 32) * x + (a % lim)) % mod
def func4(x, n):
return ((x >> 32) << 32) + (x % lim) * n % mod
def e1():
return 0
def e2():
return (1 << 32)
def main():
n, q = list(map(int, input().split()))
a = list(map(int, input().split()))
segment = LazySegmentTree(func1, e1, func3, func2, func4, e2, a)
for i in range(q):
query = list(map(int, input().split()))
if query[0] == 0:
l, r, b, c = query[1:]
segment.apply(l, r, (b << 32)+c)
else:
l, r = query[1:]
res = segment.prod(l, r)
print(res)
if __name__ == "__main__":
main()
| """
遅延評価セグメント木
op(s, t)：二項演算の関数（実際に評価する値同士の演算）：現在の値の中での比較
composition(f, g)：二項演算の関数（遅延評価する値同士の演算）：どちらの値を遅延伝播するか決定
mapping(f, a)：二項演算の関数（二つの集合についての演算（ただし、X・Mの順））：現在の値と遅延評価により生じた値のどちらを採用するかを決定
rangeop(f, length)：範囲が関係してくるときに行う演算
e()：実際に評価する値の単位元
id()：遅延評価する値の単位元
update, find, bisect, 全てにおいて, 1-indexとなっている。
(大抵の場合、Atcoderの問題文の表記のままの値を、メソッドに代入すれば良い)
"""
import sys
input = sys.stdin.readline
class LazySegmentTree:
#遅延評価セグメント木
def __init__(s, op, e, mapping, composition, rangeop, 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.rangeop = rangeop
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)
def get_length(s, i):
return pow(2, (s.size).bit_length() - (i).bit_length())
# 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(s.d[p], f)
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(s.d[k], s.rangeop(f, s.get_length(k)))
if k < s.size: s.lz[k] = s.composition(s.lz[k], f)
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
mod = 998244353
lim = 1 << 32
def func1(x, y):
return (x + y) % mod
def func2(a1, a2):
return (((a1 >> 32) * (a2 >> 32) % mod) << 32) + (((a1 % lim) * (a2 >> 32) + (a2 % lim)) % mod)
def func3(x, a):
return ((a >> 32) * x + (a % lim)) % mod
def func4(x, n):
return ((x >> 32) << 32) + (x % lim) * n % mod
def e1():
return 0
def e2():
return (1 << 32)
def main():
n, q = map(int, input().split())
a = list(map(int, input().split()))
segment = LazySegmentTree(func1, e1, func3, func2, func4, e2, a)
ans = []
for i in range(q):
query = list(map(int, input().split()))
if query[0] == 0:
l, r, b, c = query[1:]
segment.apply(l, r, (b << 32)+c)
else:
l, r = query[1:]
res = segment.prod(l, r)
ans.append(res)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| p02568 |
# foldの前計算を省いて逐次計算に。
# 同じインデックスの重複を除くので、関数の呼び出し回数が少し少ないはず。
# ただ、重複を除く分のオーバーヘッドがあるので、スピードはそこまで出ない。
MOD = 998244353
mask = (1 << 32) - 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 // (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
l0 = l // (l & -l)
r0 = r // (r & -r) - 1
# propagation
for shift in range(l0.bit_length()-1, 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()-1, 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
# 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)))
if __name__ == "__main__":
main() | # l // l & -lなどを変更。比較用。
MOD = 998244353
mask32 = (1 << 32) - 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
l0 = l
r0 = r
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 0:
r0 //= 2
r0 -= 1
# propagation
for shift in range(l0.bit_length()-1, 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()-1, 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):
l += self.n
r += self.n
l0 = l
r0 = r
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 0:
r0 //= 2
r0 -= 1
# propagation
for shift in range(l0.bit_length()-1, 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()-1, 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
# 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 yosupo():
# Monoid は (値 << 32) + 要素数 にする。
# Operator も (b << 32) + c
import sys
input = sys.stdin.buffer.readline
def fmm(m1, m2):
m = m1 + m2
return (((m >> 32) % MOD) << 32) + (m & mask32)
def fmo(m1, o1):
val = m1 >> 32
cnt = m1 & mask32
b = o1 >> 32
c = o1 & mask32
return (((b * val + c * cnt) % MOD) << 32) + cnt
def foo(o1, o2):
b1 = o1 >> 32
c1 = o1 & mask32
b2 = o2 >> 32
c2 = o2 & mask32
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))
if __name__ == "__main__":
yosupo()
| p02568 |
"""Buggy! the output of practice_k becomes about 1/4."""
from typing import Callable, List, TypeVar
S = TypeVar("S")
F = TypeVar("F")
class LazySegmentTree:
"""Lazy Segment Tree
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
"""
__slots__ = [
"e",
"op",
"id",
"mapping",
"composition",
"_n",
"_log",
"_size",
"tree",
"lazy",
]
def __init__(
self,
a: List[S],
e: S,
op: Callable[[S, S], S],
id_: F,
mapping: Callable[[F, S], S],
composition: Callable[[F, F], F],
) -> None:
self.e = e
self.op = op
self.id = id_
self.mapping = mapping
self.composition = composition
self._n = len(a)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self.tree = [e] * self._size + a + [e] * (self._size - self._n)
for i in range(self._size - 1, 0, -1):
self._update(i)
self.lazy = [id_] * self._size
def _update(self, k: int) -> None:
"""Update the value of a[k]."""
self.tree[k] = self.op(self.tree[2 * k], self.tree[2 * k + 1])
def _apply_all(self, k: int, f: F) -> None:
self.tree[k] = self.mapping(f, self.tree[k])
if k < self._size:
self.lazy[k] = self.composition(f, self.lazy[k])
def _push(self, k: int) -> None:
self._apply_all(2 * k, self.lazy[k])
self._apply_all(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def set(self, k: int, x: S) -> None:
"""Assign x to a[k] in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = x
while k:
k >>= 1
self._update(k)
def get(self, k: int) -> S:
"""Return a[k] in O(1)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
return self.tree[k]
def prod(self, l: int, r: int) -> S:
"""Return op(a[l], ..., a[r - 1]). Return e, if l == r.
Complexity: O(log n)
"""
assert 0 <= l <= r <= self._n
if l == r:
return self.e
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push(r >> i)
sml, smr = self.e, self.e
while l < r:
if l & 1:
sml = self.op(sml, self.tree[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.tree[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def prod_all(self) -> S:
"""Return op(a[0], ..., a[n - 1]. Return e if n == 0.
Complexity: O(1)
"""
return self.tree[1]
def apply(self, k: int, f: F) -> None:
"""Apply a[p] = op_st(a[p], x) in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = self.mapping(f, self.tree[k])
for i in range(1, self._log + 1):
self._update(k >> i)
def apply_range(self, l: int, r: int, f: F) -> None:
"""Apply a[i] = op_st(a[i], x) for all i = l..r-1 in O(log n)."""
assert 0 <= l <= r <= self._n
if l == r:
return
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push((r - 1) >> i)
l_tmp, r_tmp = l, r
while l < r:
if l & 1:
self._apply_all(l, f)
l += 1
if r & 1:
r -= 1
self._apply_all(r, f)
l >>= 1
r >>= 1
l, r = l_tmp, r_tmp
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: int, g: Callable[[S], bool]) -> int:
"""
Return an index r satisfying both:
1. r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
2. r = n or f(op(a[l], a[l + 1], ..., a[r])) = false.
If f is monotone, this is the maximum r satisfying:
f(op(a[l], a[l + 1], ..., a[r - 1])) = true.
Complexity: O(log n)
"""
assert 0 <= l <= self._n
assert g(self.e)
if l == self._n:
return self._n
l += self._size
for i in range(self._log, 0, -1):
self._push(l >> i)
sm = self.e
while True:
while not l & 1:
l >>= 1
if not g(self.op(sm, self.tree[l])):
while l < self._size:
l *= 2
if g(self.op(sm, self.tree[l])):
sm = self.op(sm, self.tree[l])
l += 1
return l - self._size
sm = self.op(sm, self.tree[l])
l += 1
if (l & -l) == l:
break
return self._n
def min_left(self, r: int, g: Callable[[S], bool]) -> int:
"""
Return an index l satisfying both:
1. l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
2. l = 0 or f(op(a[l - 1], a[l + 1], ..., a[r - 1])) = false.
If f is monotone, this is the minimum l satisfying:
f(op(a[l], a[l + 1], ..., a[r - 1])) = true.
Complexity: O(log n)
"""
assert 0 <= r <= self._n
assert g(self.e)
if not r:
return 0
r += self._size
for i in range(self._log, 0, -1):
self._push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r & 1:
r >>= 1
if not g(self.op(self.tree[r], sm)):
while r < self._size:
r = 2 * r + 1
if g(self.op(self.tree[r], sm)):
sm = self.op(self.tree[r], sm)
r -= 1
return r + 1 - self._size
sm = self.op(self.tree[r], sm)
if (r & -r) == r:
break
return 0
def range_affine_range_sum():
"""
https://judge.yosupo.jp/problem/range_affine_range_sum
https://atcoder.jp/contests/practice2/tasks/practice2_k
"""
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
A = [(i << 32) + 1 for i in map(int, readline().split())]
MOD = 998244353
e = 0
id_ = 1 << 32
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
tree = LazySegmentTree(A, e, op, id_, mapping, composition)
res = []
for _ in range(Q):
com, l, r, *bc = list(map(int, readline().split()))
if com:
res.append(tree.prod(l, r) >> 32)
else:
B, C = bc
tree.apply_range(l, r, (B << 32) + C)
print(("\n".join(map(str, res))))
if __name__ == "__main__":
range_affine_range_sum()
| from typing import Callable, List, TypeVar
S = TypeVar("S")
F = TypeVar("F")
class LazySegmentTree:
"""Lazy Segment Tree
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
"""
__slots__ = [
"e",
"op",
"id",
"mapping",
"composition",
"_n",
"_log",
"_size",
"tree",
"lazy",
]
def __init__(
self,
a: List[S],
e: S,
op: Callable[[S, S], S],
id_: F,
mapping: Callable[[F, S], S],
composition: Callable[[F, F], F],
) -> None:
self.e = e
self.op = op
self.id = id_
self.mapping = mapping
self.composition = composition
self._n = len(a)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self.tree = [e] * self._size + a + [e] * (self._size - self._n)
for i in range(self._size - 1, 0, -1):
self._update(i)
self.lazy = [id_] * self._size
def _update(self, k: int) -> None:
"""Update the value of a[k]."""
self.tree[k] = self.op(self.tree[2 * k], self.tree[2 * k + 1])
def _apply_all(self, k: int, f: F) -> None:
self.tree[k] = self.mapping(f, self.tree[k])
if k < self._size:
self.lazy[k] = self.composition(f, self.lazy[k])
def _push(self, k: int) -> None:
self._apply_all(2 * k, self.lazy[k])
self._apply_all(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def set(self, k: int, x: S) -> None:
"""Assign x to a[k] in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = x
while k:
k >>= 1
self._update(k)
def get(self, k: int) -> S:
"""Return a[k] in O(1)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
return self.tree[k]
def prod(self, l: int, r: int) -> S:
"""Return op(a[l], ..., a[r - 1]). Return e, if l == r.
Complexity: O(log n)
"""
assert 0 <= l <= r <= self._n
if l == r:
return self.e
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push(r >> i)
sml, smr = self.e, self.e
while l < r:
if l & 1:
sml = self.op(sml, self.tree[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.tree[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def prod_all(self) -> S:
"""Return op(a[0], ..., a[n - 1]. Return e if n == 0.
Complexity: O(1)
"""
return self.tree[1]
def apply(self, k: int, f: F) -> None:
"""Apply a[p] = op_st(a[p], x) in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = self.mapping(f, self.tree[k])
for i in range(1, self._log + 1):
self._update(k >> i)
def apply_range(self, l: int, r: int, f: F) -> None:
"""Apply a[i] = op_st(a[i], x) for all i = l..r-1 in O(log n)."""
assert 0 <= l <= r <= self._n
if l == r:
return
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push((r - 1) >> i)
l_tmp, r_tmp = l, r
while l < r:
if l & 1:
self._apply_all(l, f)
l += 1
if r & 1:
r -= 1
self._apply_all(r, f)
l >>= 1
r >>= 1
l, r = l_tmp, r_tmp
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)
import sys
readline = sys.stdin.buffer.readline
N, Q = list(map(int, readline().split()))
A = [(i << 32) + 1 for i in map(int, readline().split())]
MOD = 998244353
e = 0
id_ = 1 << 32
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
tree = LazySegmentTree(A, e, op, id_, mapping, composition)
res = []
for _ in range(Q):
com, l, r, *bc = list(map(int, readline().split()))
if com:
res.append(tree.prod(l, r) >> 32)
else:
B, C = bc
tree.apply_range(l, r, (B << 32) + C)
print(("\n".join(map(str, res))))
| p02568 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1 # sys.maxsize # float("inf")
MOD = 998244353
def set_depth(depth):
global DEPTH, SEGTREE_SIZE, NONLEAF_SIZE
DEPTH = depth
SEGTREE_SIZE = 1 << DEPTH
NONLEAF_SIZE = 1 << (DEPTH - 1)
def set_width(width):
set_depth((width - 1).bit_length() + 1)
def get_size(pos):
ret = pos.bit_length()
return (1 << (DEPTH - ret))
def up(pos):
pos += SEGTREE_SIZE // 2
return pos // (pos & -pos)
def up_propagate(table, pos, binop):
while pos > 1:
pos >>= 1
table[pos] = binop(
table[pos * 2],
table[pos * 2 + 1]
)
def full_up(table, binop):
for i in range(NONLEAF_SIZE - 1, 0, -1):
table[i] = binop(
table[2 * i],
table[2 * i + 1])
def force_down_propagate(
action_table, value_table, pos,
action_composite, action_force, action_unity
):
max_level = pos.bit_length() - 1
size = NONLEAF_SIZE
for level in range(max_level):
size //= 2
i = pos >> (max_level - level)
action = action_table[i]
if action != action_unity:
# action_table[i * 2] = action_composite(
# action, action_table[i * 2])
# action_table[i * 2 + 1] = action_composite(
# action, action_table[i * 2 + 1])
old_action = action_table[i * 2]
if old_action == action_unity:
action_table[i * 2] = action
else:
b1, c1 = old_action
b2, c2 = action
action_table[i * 2] = (b1 * b2, b2 * c1 + c2)
old_action = action_table[i * 2 + 1]
if old_action == action_unity:
action_table[i * 2 + 1] = action
else:
b1, c1 = old_action
b2, c2 = action
action_table[i * 2 + 1] = (b1 * b2, b2 * c1 + c2)
action_table[i] = action_unity
# value_table[i * 2] = action_force(
# action, value_table[i * 2], size)
# value_table[i * 2 + 1] = action_force(
# action, value_table[i * 2 + 1], size)
b, c = action
value = value_table[i * 2]
value_table[i * 2] = (value * b + c * size) % MOD
value = value_table[i * 2 + 1]
value_table[i * 2 + 1] = (value * b + c * size) % MOD
def force_range_update(
value_table, action_table, left, right,
action, action_force, action_composite, action_unity
):
"""
action_force: action, value, cell_size => new_value
action_composite: new_action, old_action => composite_action
"""
left += NONLEAF_SIZE
right += NONLEAF_SIZE
while left < right:
if left & 1:
value_table[left] = action_force(
action, value_table[left], get_size(left))
action_table[left] = action_composite(action, action_table[left])
left += 1
if right & 1:
right -= 1
value_table[right] = action_force(
action, value_table[right], get_size(right))
action_table[right] = action_composite(action, action_table[right])
left //= 2
right //= 2
def range_reduce(table, left, right, binop, unity):
ret_left = unity
ret_right = unity
left += NONLEAF_SIZE
right += NONLEAF_SIZE
while left < right:
if left & 1:
ret_left = binop(ret_left, table[left])
left += 1
if right & 1:
right -= 1
ret_right = binop(table[right], ret_right)
left //= 2
right //= 2
return binop(ret_left, ret_right)
def lazy_range_update(
action_table, value_table, start, end,
action, action_composite, action_force, action_unity, value_binop):
"update [start, end)"
L = up(start)
R = up(end)
force_down_propagate(
action_table, value_table, L,
action_composite, action_force, action_unity)
force_down_propagate(
action_table, value_table, R,
action_composite, action_force, action_unity)
# print("action", file=sys.stderr)
# debugprint(action_table)
# print("value", file=sys.stderr)
# debugprint(value_table)
# print(file=sys.stderr)
force_range_update(
value_table, action_table, start, end,
action, action_force, action_composite, action_unity)
up_propagate(value_table, L, value_binop)
up_propagate(value_table, R, value_binop)
def lazy_range_reduce(
action_table, value_table, start, end,
action_composite, action_force, action_unity,
value_binop, value_unity
):
"reduce [start, end)"
force_down_propagate(
action_table, value_table, up(start),
action_composite, action_force, action_unity)
force_down_propagate(
action_table, value_table, up(end),
action_composite, action_force, action_unity)
return range_reduce(value_table, start, end, value_binop, value_unity)
def debug(*x):
print(*x, file=sys.stderr)
def main():
# parse input
N, Q = map(int, input().split())
AS = list(map(int, input().split()))
set_width(N + 1) # include N
value_unity = 0
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE + len(AS)] = AS
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
def action_force(action, value, size):
if action == action_unity:
return value
b, c = action
return (value * b + c * size) % MOD
def action_composite(new_action, old_action):
if new_action == action_unity:
return old_action
if old_action == action_unity:
return new_action
b1, c1 = old_action
b2, c2 = new_action
return (b1 * b2, b2 * c1 + c2)
def value_binop(a, b):
return (a + b) % MOD
full_up(value_table, value_binop)
for _q in range(Q):
q, *args = map(int, input().split())
if q == 0:
l, r, b, c = args
lazy_range_update(
action_table, value_table, l, r, (b, c),
action_composite, action_force, action_unity, value_binop)
else:
l, r = args
print(lazy_range_reduce(
action_table, value_table, l, r,
action_composite, action_force, action_unity, value_binop, value_unity))
T1 = """
5 7
1 2 3 4 5
1 0 5
0 2 4 100 101
1 0 3
0 1 3 102 103
1 2 5
0 2 5 104 105
1 0 5
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
15
404
41511
4317767
"""
def _test():
import doctest
doctest.testmod()
g = globals()
for k in sorted(g):
if k.startswith("TEST_"):
doctest.run_docstring_examples(g[k], g, name=k)
def as_input(s):
"use in test, use given string as input file"
import io
f = io.StringIO(s.strip())
g = globals()
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1 # sys.maxsize # float("inf")
MOD = 998244353
def set_depth(depth):
global DEPTH, SEGTREE_SIZE, NONLEAF_SIZE
DEPTH = depth
SEGTREE_SIZE = 1 << DEPTH
NONLEAF_SIZE = 1 << (DEPTH - 1)
def set_width(width):
set_depth((width - 1).bit_length() + 1)
def get_size(pos):
ret = pos.bit_length()
return (1 << (DEPTH - ret))
def up(pos):
pos += SEGTREE_SIZE // 2
return pos // (pos & -pos)
def up_propagate(table, pos, binop):
while pos > 1:
pos >>= 1
table[pos] = binop(
table[pos * 2],
table[pos * 2 + 1]
)
def full_up(table, binop):
for i in range(NONLEAF_SIZE - 1, 0, -1):
table[i] = binop(
table[2 * i],
table[2 * i + 1])
def force_down_propagate(
action_table, value_table, pos,
action_composite, action_force, action_unity
):
max_level = pos.bit_length() - 1
size = NONLEAF_SIZE
for level in range(max_level):
size //= 2
i = pos >> (max_level - level)
action = action_table[i]
if action != action_unity:
action_table[i * 2] = action_composite(
action, action_table[i * 2])
action_table[i * 2 + 1] = action_composite(
action, action_table[i * 2 + 1])
# old_action = action_table[i * 2]
# if old_action == action_unity:
# action_table[i * 2] = action
# else:
# b1, c1 = old_action
# b2, c2 = action
# action_table[i * 2] = (b1 * b2, b2 * c1 + c2)
# old_action = action_table[i * 2 + 1]
# if old_action == action_unity:
# action_table[i * 2 + 1] = action
# else:
# b1, c1 = old_action
# b2, c2 = action
# action_table[i * 2 + 1] = (b1 * b2, b2 * c1 + c2)
action_table[i] = action_unity
value_table[i * 2] = action_force(
action, value_table[i * 2], size)
value_table[i * 2 + 1] = action_force(
action, value_table[i * 2 + 1], size)
# b, c = action
# value = value_table[i * 2]
# value_table[i * 2] = (value * b + c * size) % MOD
# value = value_table[i * 2 + 1]
# value_table[i * 2 + 1] = (value * b + c * size) % MOD
def force_range_update(
value_table, action_table, left, right,
action, action_force, action_composite, action_unity
):
"""
action_force: action, value, cell_size => new_value
action_composite: new_action, old_action => composite_action
"""
left += NONLEAF_SIZE
right += NONLEAF_SIZE
while left < right:
if left & 1:
value_table[left] = action_force(
action, value_table[left], get_size(left))
action_table[left] = action_composite(action, action_table[left])
left += 1
if right & 1:
right -= 1
value_table[right] = action_force(
action, value_table[right], get_size(right))
action_table[right] = action_composite(action, action_table[right])
left //= 2
right //= 2
def range_reduce(table, left, right, binop, unity):
ret_left = unity
ret_right = unity
left += NONLEAF_SIZE
right += NONLEAF_SIZE
while left < right:
if left & 1:
ret_left = binop(ret_left, table[left])
left += 1
if right & 1:
right -= 1
ret_right = binop(table[right], ret_right)
left //= 2
right //= 2
return binop(ret_left, ret_right)
def lazy_range_update(
action_table, value_table, start, end,
action, action_composite, action_force, action_unity, value_binop):
"update [start, end)"
L = up(start)
R = up(end)
force_down_propagate(
action_table, value_table, L,
action_composite, action_force, action_unity)
force_down_propagate(
action_table, value_table, R,
action_composite, action_force, action_unity)
force_range_update(
value_table, action_table, start, end,
action, action_force, action_composite, action_unity)
up_propagate(value_table, L, value_binop)
up_propagate(value_table, R, value_binop)
def lazy_range_reduce(
action_table, value_table, start, end,
action_composite, action_force, action_unity,
value_binop, value_unity
):
"reduce [start, end)"
force_down_propagate(
action_table, value_table, up(start),
action_composite, action_force, action_unity)
force_down_propagate(
action_table, value_table, up(end),
action_composite, action_force, action_unity)
return range_reduce(value_table, start, end, value_binop, value_unity)
def debug(*x):
print(*x, file=sys.stderr)
def main():
# parse input
N, Q = map(int, input().split())
AS = list(map(int, input().split()))
set_width(N + 1) # include N
value_unity = 0
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE + len(AS)] = AS
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
def action_force(action, value, size):
if action == action_unity:
return value
# b, c = action
b = action >> 32
c = action - (b << 32)
return (value * b + c * size) % MOD
def action_composite(new_action, old_action):
if new_action == action_unity:
return old_action
if old_action == action_unity:
return new_action
b1 = old_action >> 32
c1 = old_action - (b1 << 32)
# b1, c1 = old_action
# b2, c2 = new_action
b2 = new_action >> 32
c2 = new_action - (b2 << 32)
b = (b1 * b2) % MOD
c = (b2 * c1 + c2) % MOD
return (b << 32) + c
def value_binop(a, b):
return (a + b) % MOD
full_up(value_table, value_binop)
for _q in range(Q):
q, *args = map(int, input().split())
if q == 0:
l, r, b, c = args
lazy_range_update(
action_table, value_table, l, r, ((b << 32) + c),
action_composite, action_force, action_unity, value_binop)
else:
l, r = args
print(lazy_range_reduce(
action_table, value_table, l, r,
action_composite, action_force, action_unity, value_binop, value_unity))
T1 = """
5 7
1 2 3 4 5
1 0 5
0 2 4 100 101
1 0 3
0 1 3 102 103
1 2 5
0 2 5 104 105
1 0 5
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
15
404
41511
4317767
"""
def _test():
import doctest
doctest.testmod()
g = globals()
for k in sorted(g):
if k.startswith("TEST_"):
doctest.run_docstring_examples(g[k], g, name=k)
def as_input(s):
"use in test, use given string as input file"
import io
f = io.StringIO(s.strip())
g = globals()
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| p02568 |
# base
# https://beet-aizu.github.io/library/library/segtree/basic/chien.cpp.html
# https://beet-aizu.hatenablog.com/entry/2017/12/01/225955
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.h = ceil_pow2(l)
self.size = 1 << self.h
# self.size = 1 << (l - 1).bit_length()
# self.h = self.size.bit_length()
self.d = [self.e() for _ in range(2*self.size)]
self.lz = [self.ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.h, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.h+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.h, 0, -1):
self.__push(p >> i)
return self.d[p]
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.h, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.h, 0, -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.h+1):
if ((l >> i) << i) != l:
self.__update(l >> i)
if ((r >> i) << i) != r:
self.__update((r-1) >> i)
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.ie()
def atcoder_practice_k():
N, Q = list(map(int, input().split()))
A = list([(int(x)<<32) +1 for x in input().split()])
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
# op = lambda l, r: ((l[0] + r[0])%M, (l[1] + r[1])%M)
# e = lambda: (0, 0)
# mapping = lambda l, r: ((r[0] * l[0] + r[1] * l[1])%M, r[1])
# composition = lambda l, r: ((r[0] * l[0])%M, (r[1] * l[0] + l[1])%M)
# ie = lambda: (1, 0)
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b<<32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
if __name__ == "__main__":
atcoder_practice_k()
|
# base
# https://beet-aizu.github.io/library/library/segtree/basic/chien.cpp.html
# https://beet-aizu.hatenablog.com/entry/2017/12/01/225955
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.h = ceil_pow2(l)
self.size = 1 << self.h
# self.size = 1 << (l - 1).bit_length()
# self.h = self.size.bit_length()
self.d = [self.e() for _ in range(2*self.size)]
self.lz = [self.ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.h, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.h+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.h, 0, -1):
self.__push(p >> i)
return self.d[p]
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.h, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.h, 0, -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.h+1):
if ((l >> i) << i) != l:
self.__update(l >> i)
if ((r >> i) << i) != r:
self.__update((r-1) >> i)
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.ie()
def atcoder_practice_k():
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
A = list([(int(x)<<32) +1 for x in input().split()])
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
# op = lambda l, r: ((l[0] + r[0])%M, (l[1] + r[1])%M)
# e = lambda: (0, 0)
# mapping = lambda l, r: ((r[0] * l[0] + r[1] * l[1])%M, r[1])
# composition = lambda l, r: ((r[0] * l[0])%M, (r[1] * l[0] + l[1])%M)
# ie = lambda: (1, 0)
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b<<32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
if __name__ == "__main__":
atcoder_practice_k()
| p02568 |
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.log = ceil_pow2(l)
self.size = 1 << self.log
# self.size = 1 << (l - 1).bit_length()
# self.h = self.size.bit_length()
self.d = [self.e() for _ in range(2*self.size)]
self.lz = [self.ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
return self.d[p]
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.log, 0, -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 __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.ie()
def atcoder_practice_k():
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = list([(int(x)<<32) +1 for x in input().split()])
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
# op = lambda l, r: ((l[0] + r[0])%M, (l[1] + r[1])%M)
# e = lambda: (0, 0)
# mapping = lambda l, r: ((r[0] * l[0] + r[1] * l[1])%M, r[1])
# composition = lambda l, r: ((r[0] * l[0])%M, (r[1] * l[0] + l[1])%M)
# ie = lambda: (1, 0)
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b<<32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
if __name__ == "__main__":
atcoder_practice_k()
| class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.log = ceil_pow2(l)
self.size = 1 << self.log
# self.size = 1 << (l - 1).bit_length()
# self.h = self.size.bit_length()
self.d = [e() for _ in range(2*self.size)]
self.lz = [ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
return self.d[p]
# @profile
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
# @profile
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.log, 0, -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 __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.ie()
# @profile
def atcoder_practice_k():
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = list([(int(x)<<32) +1 for x in input().split()])
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
# op = lambda l, r: ((l[0] + r[0])%M, (l[1] + r[1])%M)
# e = lambda: (0, 0)
# mapping = lambda l, r: ((r[0] * l[0] + r[1] * l[1])%M, r[1])
# composition = lambda l, r: ((r[0] * l[0])%M, (r[1] * l[0] + l[1])%M)
# ie = lambda: (1, 0)
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b<<32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
if __name__ == "__main__":
atcoder_practice_k()
| p02568 |
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.log = ceil_pow2(l)
self.size = 1 << self.log
# self.size = 1 << (l - 1).bit_length()
# self.h = self.size.bit_length()
self.d = [e() for _ in range(2*self.size)]
self.lz = [ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
return self.d[p]
# @profile
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
# @profile
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.log, 0, -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 __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.ie()
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
# @profile
def atcoder_practice_k():
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = list([(int(x)<<32) +1 for x in input().split()])
# op = lambda l, r: ((l[0] + r[0])%M, (l[1] + r[1])%M)
# e = lambda: (0, 0)
# mapping = lambda l, r: ((r[0] * l[0] + r[1] * l[1])%M, r[1])
# composition = lambda l, r: ((r[0] * l[0])%M, (r[1] * l[0] + l[1])%M)
# ie = lambda: (1, 0)
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b<<32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
if __name__ == "__main__":
atcoder_practice_k()
| class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.log = ceil_pow2(l)
self.size = 1 << self.log
# self.size = 1 << (l - 1).bit_length()
# self.h = self.size.bit_length()
self.d = [e() for _ in range(2*self.size)]
self.lz = [ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
return self.d[p]
# @profile
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
# @profile
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.log, 0, -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 __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.ie()
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = list([(int(x) << 32) + 1 for x in input().split()])
# op = lambda l, r: ((l[0] + r[0])%M, (l[1] + r[1])%M)
# e = lambda: (0, 0)
# mapping = lambda l, r: ((r[0] * l[0] + r[1] * l[1])%M, r[1])
# composition = lambda l, r: ((r[0] * l[0])%M, (r[1] * l[0] + l[1])%M)
# ie = lambda: (1, 0)
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b << 32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
# # @profile
# def atcoder_practice_k():
# if __name__ == "__main__":
# atcoder_practice_k()
| p02568 |
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.log = ceil_pow2(l)
self.size = 1 << self.log
self.d = [e() for _ in range(2*self.size)]
self.lz = [ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
return self.d[p]
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, p, f):
# p += self.size
# for i in range(self.h, 0, -1):
# self.__push(p >> i)
# self.d[p] = self.mapping(f, self.d[p])
# for i in range(1, self.h+1):
# self.__update(p >> i)
def apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.log, 0, -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 __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.ie()
MOD = 998244353
def op(l, r): return ((l[0] + r[0]) % MOD, (l[1] + r[1]) % MOD)
def e(): return (0, 0)
def mapping(l, r): return ((r[0] * l[0] + r[1] * l[1]) % MOD, r[1])
def composition(l, r): return ((r[0] * l[0]) % MOD, (r[1] * l[0] + l[1]) % MOD)
def ie(): return (1, 0)
def atcoder_practice_k():
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = list([(int(x), 1) for x in input().split()])
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b, c))
else:
l, r = q
a = st.prod(l, r)
print((a[0]))
if __name__ == "__main__":
atcoder_practice_k()
| class LazySegmentTree():
def __init__(self, op, e, mapping, composition, ie, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.ie = ie
l = len(init_array)
def ceil_pow2(n):
x = 0
while (1 << x) < n:
x += 1
return x
self.log = ceil_pow2(l)
self.size = 1 << self.log
self.d = [e() for _ in range(2*self.size)]
self.lz = [ie() for _ in range(self.size)]
for i, a in enumerate(init_array):
self.d[i+self.size] = a
for i in range(self.size-1, 0, -1):
self.__update(i)
def set(self, p, x):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log+1):
self.__update(p >> i)
def __getitem__(self, p):
p += self.size
for i in range(self.log, 0, -1):
self.__push(p >> i)
return self.d[p]
def prod(self, l, r):
if l == r:
return self.e()
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l:
self.__push(l >> i)
if ((r >> i) << i) != r:
self.__push(r >> i)
sml = self.e()
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 apply(self, l, r, f):
if l == r:
return
l += self.size
r += self.size
for i in range(self.log, 0, -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 __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.ie()
MOD = 998244353
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def ie():
return 1 << 32
def atcoder_practice_k():
import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
A = list([(int(x)<<32) +1 for x in input().split()])
st = LazySegmentTree(op, e, mapping, composition, ie, A)
for _ in range(Q):
k, *q = list(map(int, input().split()))
if k == 0:
l, r, b, c = q
st.apply(l, r, (b<<32) + c)
else:
l, r = q
a = st.prod(l, r)
print((a >> 32))
if __name__ == "__main__":
atcoder_practice_k()
| p02568 |
import sys
readline = sys.stdin.readline
class Lazysegtree:
def __init__(self, A, fx, ex, fm, initialize = True):
#作用の単位元をNoneにしている
#fa(operator, idx)の形にしている、data[idx]の長さに依存する場合などのため
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.ex = ex
self.fx = fx
self.fm = fm
self.lazy = [None]*(2*self.N0)
if initialize:
self.data = [self.ex]*self.N0 + A + [self.ex]*(self.N0 - self.N)
for i in range(self.N0-1, -1, -1):
self.data[i] = self.fx(self.data[2*i], self.data[2*i+1])
else:
self.data = [self.ex]*(2*self.N0)
def fa(self, ope, idx):
"""
TO WRITE
"""
k = idx.bit_length()
return (ope[0]*self.data[idx] + (self.N0>>(k-1))*ope[1])%MOD
def __repr__(self):
s = 'data'
l = 'lazy'
cnt = 1
for i in range(self.N0.bit_length()):
s = '\n'.join((s, ' '.join(map(str, self.data[cnt:cnt+(1<<i)]))))
l = '\n'.join((l, ' '.join(map(str, self.lazy[cnt:cnt+(1<<i)]))))
cnt += 1<<i
return '\n'.join((s, l))
def _ascend(self, k):
k = k >> 1
c = k.bit_length()
for j in range(c):
idx = k >> j
self.data[idx] = self.fx(self.data[2*idx], self.data[2*idx+1])
def _descend(self, k):
k = k >> 1
idx = 1
c = k.bit_length()
for j in range(1, c+1):
idx = k >> (c - j)
if self.lazy[idx] is None:
continue
self.data[2*idx] = self.fa(self.lazy[idx], 2*idx)
self.data[2*idx+1] = self.fa(self.lazy[idx], 2*idx+1)
if self.lazy[2*idx] is not None:
self.lazy[2*idx] = self.fm(self.lazy[idx], self.lazy[2*idx])
else:
self.lazy[2*idx] = self.lazy[idx]
if self.lazy[2*idx+1] is not None:
self.lazy[2*idx+1] = self.fm(self.lazy[idx], self.lazy[2*idx+1])
else:
self.lazy[2*idx+1] = self.lazy[idx]
self.lazy[idx] = None
def query(self, l, r):
L = l+self.N0
R = r+self.N0
self._descend(L//(L & -L))
self._descend(R//(R & -R)-1)
sl = self.ex
sr = self.ex
while L < R:
if R & 1:
R -= 1
sr = self.fx(self.data[R], sr)
if L & 1:
sl = self.fx(sl, self.data[L])
L += 1
L >>= 1
R >>= 1
return self.fx(sl, sr)
def operate(self, l, r, x):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
self._descend(Li)
self._descend(Ri-1)
while L < R :
if R & 1:
R -= 1
self.data[R] = self.fa(x, R)
if self.lazy[R] is None:
self.lazy[R] = x
else:
self.lazy[R] = self.fm(x, self.lazy[R])
if L & 1:
self.data[L] = self.fa(x, L)
if self.lazy[L] is None:
self.lazy[L] = x
else:
self.lazy[L] = self.fm(x, self.lazy[L])
L += 1
L >>= 1
R >>= 1
self._ascend(Li)
self._ascend(Ri-1)
MOD = 998244353
def fx(x, y):
return (x+y)%MOD
def fm(o, p):
return ((o[0]*p[0])%MOD, (o[0]*p[1] + o[1])%MOD)
N, Q = list(map(int, readline().split()))
A = list(map(int, readline().split()))
T = Lazysegtree(A, fx, 0, fm, initialize = True)
Ans = []
for _ in range(Q):
t, *s = readline().split()
if t == '0':
l, r, b, c = list(map(int, s))
T.operate(l, r, (b, c))
else:
l, r = list(map(int, s))
Ans.append(T.query(l, r))
print(('\n'.join(map(str, Ans)))) | import sys
readline = sys.stdin.readline
class Lazysegtree:
def __init__(self, A, fx, ex, fm, initialize = True):
#作用の単位元をNoneにしている
#fa(operator, idx)の形にしている、data[idx]の長さに依存する場合などのため
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.ex = ex
self.lazy = [None]*(2*self.N0)
if initialize:
self.data = [self.ex]*self.N0 + A + [self.ex]*(self.N0 - self.N)
for i in range(self.N0-1, -1, -1):
self.data[i] = self.fx(self.data[2*i], self.data[2*i+1])
else:
self.data = [self.ex]*(2*self.N0)
def fx(self, x, y):
return (x+y)%MOD
def fm(self, o, p):
o1 = o>>32
return ((o1*(p>>32)%MOD)<<32) + (o1*(p&mask) + (o&mask))%MOD
def fa(self, ope, idx):
"""
TO WRITE
"""
k = idx.bit_length()
return ((ope>>32)*self.data[idx] + (self.N0>>(k-1))*(ope&mask))%MOD
def __repr__(self):
s = 'data'
l = 'lazy'
cnt = 1
for i in range(self.N0.bit_length()):
s = '\n'.join((s, ' '.join(map(str, self.data[cnt:cnt+(1<<i)]))))
l = '\n'.join((l, ' '.join(map(str, self.lazy[cnt:cnt+(1<<i)]))))
cnt += 1<<i
return '\n'.join((s, l))
def _ascend(self, k):
k = k >> 1
c = k.bit_length()
for j in range(c):
idx = k >> j
self.data[idx] = self.fx(self.data[2*idx], self.data[2*idx+1])
def _descend(self, k):
k = k >> 1
idx = 1
c = k.bit_length()
for j in range(1, c+1):
idx = k >> (c - j)
if self.lazy[idx] is None:
continue
self.data[2*idx] = self.fa(self.lazy[idx], 2*idx)
self.data[2*idx+1] = self.fa(self.lazy[idx], 2*idx+1)
if self.lazy[2*idx] is not None:
self.lazy[2*idx] = self.fm(self.lazy[idx], self.lazy[2*idx])
else:
self.lazy[2*idx] = self.lazy[idx]
if self.lazy[2*idx+1] is not None:
self.lazy[2*idx+1] = self.fm(self.lazy[idx], self.lazy[2*idx+1])
else:
self.lazy[2*idx+1] = self.lazy[idx]
self.lazy[idx] = None
def query(self, l, r):
L = l+self.N0
R = r+self.N0
self._descend(L//(L & -L))
self._descend(R//(R & -R)-1)
sl = self.ex
sr = self.ex
while L < R:
if R & 1:
R -= 1
sr = self.fx(self.data[R], sr)
if L & 1:
sl = self.fx(sl, self.data[L])
L += 1
L >>= 1
R >>= 1
return self.fx(sl, sr)
def operate(self, l, r, x):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
self._descend(Li)
self._descend(Ri-1)
while L < R :
if R & 1:
R -= 1
self.data[R] = self.fa(x, R)
if self.lazy[R] is None:
self.lazy[R] = x
else:
self.lazy[R] = self.fm(x, self.lazy[R])
if L & 1:
self.data[L] = self.fa(x, L)
if self.lazy[L] is None:
self.lazy[L] = x
else:
self.lazy[L] = self.fm(x, self.lazy[L])
L += 1
L >>= 1
R >>= 1
self._ascend(Li)
self._ascend(Ri-1)
MOD = 998244353
mask = (1<<32) - 1
N, Q = list(map(int, readline().split()))
A = list(map(int, readline().split()))
T = Lazysegtree(A, None, 0, None, initialize = True)
Ans = []
for _ in range(Q):
t, *s = readline().split()
if t == '0':
l, r, b, c = list(map(int, s))
T.operate(l, r, (b<<32)+c)
else:
l, r = list(map(int, s))
Ans.append(T.query(l, r))
print(('\n'.join(map(str, Ans))))
| p02568 |
import sys
readline = sys.stdin.readline
class Lazysegtree:
def __init__(self, A, fx, ex, fm, initialize = True):
#作用の単位元をNoneにしている
#fa(operator, idx)の形にしている、data[idx]の長さに依存する場合などのため
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.ex = ex
self.lazy = [None]*(2*self.N0)
if initialize:
self.data = [self.ex]*self.N0 + A + [self.ex]*(self.N0 - self.N)
for i in range(self.N0-1, -1, -1):
self.data[i] = self.fx(self.data[2*i], self.data[2*i+1])
else:
self.data = [self.ex]*(2*self.N0)
def fx(self, x, y):
return (x+y)%MOD
def fm(self, o, p):
o1 = o>>32
return ((o1*(p>>32)%MOD)<<32) + (o1*(p&mask) + (o&mask))%MOD
def fa(self, ope, idx):
"""
TO WRITE
"""
k = idx.bit_length()
return ((ope>>32)*self.data[idx] + (self.N0>>(k-1))*(ope&mask))%MOD
def __repr__(self):
s = 'data'
l = 'lazy'
cnt = 1
for i in range(self.N0.bit_length()):
s = '\n'.join((s, ' '.join(map(str, self.data[cnt:cnt+(1<<i)]))))
l = '\n'.join((l, ' '.join(map(str, self.lazy[cnt:cnt+(1<<i)]))))
cnt += 1<<i
return '\n'.join((s, l))
def _ascend(self, k):
k = k >> 1
c = k.bit_length()
for j in range(c):
idx = k >> j
self.data[idx] = self.fx(self.data[2*idx], self.data[2*idx+1])
def _descend(self, k):
k = k >> 1
idx = 1
c = k.bit_length()
for j in range(1, c+1):
idx = k >> (c - j)
if self.lazy[idx] is None:
continue
self.data[2*idx] = self.fa(self.lazy[idx], 2*idx)
self.data[2*idx+1] = self.fa(self.lazy[idx], 2*idx+1)
if self.lazy[2*idx] is not None:
self.lazy[2*idx] = self.fm(self.lazy[idx], self.lazy[2*idx])
else:
self.lazy[2*idx] = self.lazy[idx]
if self.lazy[2*idx+1] is not None:
self.lazy[2*idx+1] = self.fm(self.lazy[idx], self.lazy[2*idx+1])
else:
self.lazy[2*idx+1] = self.lazy[idx]
self.lazy[idx] = None
def query(self, l, r):
L = l+self.N0
R = r+self.N0
self._descend(L//(L & -L))
self._descend(R//(R & -R)-1)
sl = self.ex
sr = self.ex
while L < R:
if R & 1:
R -= 1
sr = self.fx(self.data[R], sr)
if L & 1:
sl = self.fx(sl, self.data[L])
L += 1
L >>= 1
R >>= 1
return self.fx(sl, sr)
def operate(self, l, r, x):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
self._descend(Li)
self._descend(Ri-1)
while L < R :
if R & 1:
R -= 1
self.data[R] = self.fa(x, R)
if self.lazy[R] is None:
self.lazy[R] = x
else:
self.lazy[R] = self.fm(x, self.lazy[R])
if L & 1:
self.data[L] = self.fa(x, L)
if self.lazy[L] is None:
self.lazy[L] = x
else:
self.lazy[L] = self.fm(x, self.lazy[L])
L += 1
L >>= 1
R >>= 1
self._ascend(Li)
self._ascend(Ri-1)
MOD = 998244353
mask = (1<<32) - 1
N, Q = list(map(int, readline().split()))
A = list(map(int, readline().split()))
T = Lazysegtree(A, None, 0, None, initialize = True)
Ans = []
for _ in range(Q):
t, *s = readline().split()
if t == '0':
l, r, b, c = list(map(int, s))
T.operate(l, r, (b<<32)+c)
else:
l, r = list(map(int, s))
Ans.append(T.query(l, r))
print(('\n'.join(map(str, Ans))))
| import sys
readline = sys.stdin.readline
class Lazysegtree:
def __init__(self, A, fx, ex, em, fm, fa, initialize = True):
#fa(operator, idx)の形にしている、data[idx]の長さに依存する場合などのため
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
"""
self.fx = fx
self.fa = fa
self.fm = fm
"""
self.ex = ex
self.em = em
self.lazy = [em]*(2*self.N0)
if initialize:
self.data = [self.ex]*self.N0 + A + [self.ex]*(self.N0 - self.N)
for i in range(self.N0-1, -1, -1):
self.data[i] = self.fx(self.data[2*i], self.data[2*i+1])
else:
self.data = [self.ex]*(2*self.N0)
def fx(self, x, y):
return (x+y)%MOD
def fm(self, o, p):
o1 = o>>32
return ((o1*(p>>32)%MOD)<<32) + (o1*(p&mask) + (o&mask))%MOD
def fa(self, ope, idx):
"""
TO WRITE
"""
k = idx.bit_length()
return ((ope>>32)*self.data[idx] + (self.N0>>(k-1))*(ope&mask))%MOD
def __repr__(self):
s = 'data'
l = 'lazy'
cnt = 1
for i in range(self.N0.bit_length()):
s = '\n'.join((s, ' '.join(map(str, self.data[cnt:cnt+(1<<i)]))))
l = '\n'.join((l, ' '.join(map(str, self.lazy[cnt:cnt+(1<<i)]))))
cnt += 1<<i
return '\n'.join((s, l))
def _ascend(self, k):
k = k >> 1
c = k.bit_length()
for j in range(c):
idx = k >> j
self.data[idx] = self.fx(self.data[2*idx], self.data[2*idx+1])
def _descend(self, k):
k = k >> 1
idx = 1
c = k.bit_length()
for j in range(1, c+1):
idx = k >> (c - j)
if self.lazy[idx] == self.em:
continue
self.data[2*idx] = self.fa(self.lazy[idx], 2*idx)
self.data[2*idx+1] = self.fa(self.lazy[idx], 2*idx+1)
self.lazy[2*idx] = self.fm(self.lazy[idx], self.lazy[2*idx])
self.lazy[2*idx+1] = self.fm(self.lazy[idx], self.lazy[2*idx+1])
self.lazy[idx] = self.em
def query(self, l, r):
L = l+self.N0
R = r+self.N0
self._descend(L//(L & -L))
self._descend(R//(R & -R)-1)
sl = self.ex
sr = self.ex
while L < R:
if R & 1:
R -= 1
sr = self.fx(self.data[R], sr)
if L & 1:
sl = self.fx(sl, self.data[L])
L += 1
L >>= 1
R >>= 1
return self.fx(sl, sr)
def operate(self, l, r, x):
L = l+self.N0
R = r+self.N0
Li = L//(L & -L)
Ri = R//(R & -R)
self._descend(Li)
self._descend(Ri-1)
while L < R :
if R & 1:
R -= 1
self.data[R] = self.fa(x, R)
self.lazy[R] = self.fm(x, self.lazy[R])
if L & 1:
self.data[L] = self.fa(x, L)
self.lazy[L] = self.fm(x, self.lazy[L])
L += 1
L >>= 1
R >>= 1
self._ascend(Li)
self._ascend(Ri-1)
MOD = 998244353
mask = (1<<32) - 1
N, Q = list(map(int, readline().split()))
A = list(map(int, readline().split()))
T = Lazysegtree(A, None, 0, 1<<32, None, None, initialize = True)
Ans = []
for _ in range(Q):
t, *s = readline().split()
if t == '0':
l, r, b, c = list(map(int, s))
T.operate(l, r, (b<<32)+c)
else:
l, r = list(map(int, s))
Ans.append(T.query(l, r))
print(('\n'.join(map(str, Ans))))
| p02568 |
#自前ModInt
class ModInt:
MOD = 10 ** 9 + 7
def __init__(s, x):
if type(x) == int:
s.x = x % type(s).MOD
else:
s.x = x
@classmethod
def set_mod(c, m):
c.MOD = m
def inv(s):
return type(s)(pow(s.x, type(s).MOD - 2, type(s).MOD))
def __str__(s):
return str(s.x)
__repr__ = __str__
def __add__(s, t):
return type(s)(s.x + t.x) if isinstance(t, ModInt) else type(s)(s.x + t)
def __sub__(s, t):
return type(s)(s.x - t.x) if isinstance(t, ModInt) else type(s)(s.x - t)
def __mul__(s, t):
return type(s)(s.x * t.x) if isinstance(t, ModInt) else type(s)(s.x * t)
def __truediv__(s, t):
return type(s)(s.x * pow(t.x, type(s).MOD - 2, type(s).MOD)) if isinstance(t, ModInt) else type(s)(s.x * pow(t, type(s).MOD - 2, type(s).MOD))
def __pow__(s, t):
return type(s)(pow(s.x, t.x, type(s).MOD)) if isinstance(t, ModInt) else type(s)(pow(s.x, t, type(s).MOD))
__radd__ = __add__
def __rsub__(s, t):
return type(s)(t.x - s.x) if isinstance(t, ModInt) else type(s)(t - s.x)
__rmul__ = __mul__
def __rtruediv__(s, t):
return type(s)(t.x * pow(s.x, type(s).MOD - 2, type(s).MOD)) if isinstance(t, ModInt) else type(s)(t * pow(s.x, type(s).MOD - 2, type(s).MOD))
def __rpow__(s, t):
return type(s)(pow(t.x, s.x, type(s).MOD)) if isinstance(t, ModInt) else type(s)(pow(t, s.x, type(s).MOD))
def __eq__(s, t):
return s.x == t.x
def __lt__(s, t):
return s.x < t.x
def __le__(s, t):
return s.x <= t.x
def __gt__(s, t):
return s.x > t.x
def __ge__(s, t):
return s.x >= t.x
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 _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
import sys
class data:
def __init__(s, val, num):
s.v = ModInt(val)
s.n = num
class mip:
def __init__(s, b, c):
s.b = b
s.c = c
def e():
return data(0, 0)
def op(s, t):
return data(s.v + t.v, s.n + t.n)
def mapping(f, a):
return data(f.b * a.v + f.c * a.n, a.n)
def composition(f, g):
return mip(f.b * g.b, g.c * f.b + f.c)
def id():
return mip(1, 0)
input = sys.stdin.readline
MOD = 998244353
ModInt.set_mod(MOD)
N, Q = list(map(int, input().split()))
a = [data(int(i), 1) for i in input().split()]
Query = (tuple(map(int, input().split())) for _ in range(Q))
seg = lazy_segtree(op, e, mapping, composition, id, a)
for q in Query:
if q[0] == 0:
_, l, r, b, c = q
seg.apply(l, r, mip(b, c))
else:
_, l, r = q
print((seg.prod(l, r).v))
| 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 _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
import sys
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def id():
return 1 << 32
input = sys.stdin.readline
MOD = 998244353
N, Q = list(map(int, input().split()))
a = [(int(i) << 32) + 1 for i in input().split()]
Query = (tuple(map(int, input().split())) for _ in range(Q))
seg = lazy_segtree(op, e, mapping, composition, id, a)
for q in Query:
if q[0] == 0:
_, l, r, b, c = q
seg.apply(l, r, (b << 32) + c)
else:
_, l, r = q
print((seg.prod(l, r) >> 32)) | p02568 |
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 _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
import sys
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def id():
return 1 << 32
MOD = 998244353
def main():
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
a = [(int(i) << 32) + 1 for i in input().split()]
Query = (tuple(map(int, input().split())) for _ in range(Q))
seg = lazy_segtree(op, e, mapping, composition, id, a)
for q in Query:
if q[0] == 0:
_, l, r, b, c = q
seg.apply(l, r, (b << 32) + c)
else:
_, l, r = q
print((seg.prod(l, r) >> 32))
main() | 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
import sys
def e():
return 0
def op(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def mapping(f, a):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
def id():
return 1 << 32
MOD = 998244353
def main():
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
a = [(int(i) << 32) + 1 for i in input().split()]
Query = (tuple(map(int, input().split())) for _ in range(Q))
seg = lazy_segtree(op, e, mapping, composition, id, a)
for q in Query:
if q[0] == 0:
_, l, r, b, c = q
seg.apply(l, r, (b << 32) + c)
else:
_, l, r = q
print((seg.prod(l, r) >> 32))
main() | p02568 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
MOD = 998244353
class LazySegTree(): # モノイドに対して適用可能、Nが2冪でなくても良い
def __init__(self, initial_values, monoid_func, composition, operate, monoid_identity, operator_identity):
self.N = len(initial_values)
self.monoid_func = monoid_func
self.composition = composition
self.operate = operate
self.monoid_identity = monoid_identity
self.operator_identity = operator_identity
self.data = [self.monoid_identity]*(2*self.N)
self.lazy = [self.operator_identity]*(2*self.N)
self.size = [0]*(2*self.N)
for i, ai in enumerate(initial_values):
self.data[self.N+i] = ai
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
self.size[i] = self.size[i << 1] + self.size[i << 1 | 1]
def update(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.data[i] = x
i >>= 1
while i:
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
i >>= 1
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.data[i],self.lazy[i],self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
i >>= 1
while i:
self.data[i] = self.monoid_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
i >>= 1
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.data[i] = self.operate(self.data[i],self.lazy[i],self.size[i])
self.lazy[i << 1] = self.composition(self.lazy[i << 1],self.lazy[i])
self.lazy[i << 1 | 1] = self.composition(self.lazy[i << 1 | 1], self.lazy[i])
self.lazy[i] = self.operator_identity
def propagate_above(self,i): # i番目より上で作用を施す
H = i.bit_length()
for h in range(H,0,-1):
self.propagate_at(i >> h)
def fold(self, L, R): # [L,R)の区間取得
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
vL = self.monoid_identity
vR = self.monoid_identity
while L < R:
if L & 1:
vL = self.monoid_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.monoid_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.monoid_func(vL,vR)
#重たい
def operate_range(self,L,R,x): # [L,R)にxを作用
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
while L < R:
if L & 1:
self.lazy[L] = self.composition(self.lazy[L], x)
L += 1
if R & 1:
R -= 1
self.lazy[R] = self.composition(self.lazy[R], x)
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
def main():
mod = 998244353
def monoid_func(x,y):
return (x+y) % mod
def composition(a,b):
b0,c0 = a
b1,c1 = b
return ((b0*b1) % mod,(b1*c0+c1) % mod)
def operate(x,a,r): # 右作用
b,c = a
return (b*x+c*r) % mod
monoid_identity = 0
operator_identity = (1,0)
N, Q = LI()
A = LI()
LST = LazySegTree(A, monoid_func, composition, operate, monoid_identity, operator_identity)
for q in LIR(Q):
if q[0] == 0:
_, l, r, b, c = q
LST.operate_range(l,r,(b,c))
else:
_, l, r = q
print((LST.fold(l,r)))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(1000000)
class LazySegTree(): # モノイドに対して適用可能、Nが2冪でなくても良い
def __init__(self, initial_values, monoid_func, composition, operate, monoid_identity, operator_identity):
self.N = len(initial_values)
self.monoid_func = monoid_func
self.composition = composition
self.operate = operate
self.monoid_identity = monoid_identity
self.operator_identity = operator_identity
self.data = [self.monoid_identity]*(2*self.N)
self.lazy = [self.operator_identity]*(2*self.N)
self.size = [0]*(2*self.N)
for i, ai in enumerate(initial_values):
self.data[self.N+i] = ai
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
self.size[i] = self.size[i << 1] + self.size[i << 1 | 1]
def update(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.data[i] = x
while i>1:
i >>= 1
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.data[i],self.lazy[i],self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
while i > 1:
i >>= 1
self.data[i] = self.monoid_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.data[i] = self.operate(self.data[i],self.lazy[i],self.size[i])
self.lazy[i << 1] = self.composition(self.lazy[i << 1],self.lazy[i])
self.lazy[i << 1 | 1] = self.composition(self.lazy[i << 1 | 1], self.lazy[i])
self.lazy[i] = self.operator_identity
def propagate_above(self,i): # i番目より上で作用を施す
H = i.bit_length()
for h in range(H,0,-1):
self.propagate_at(i >> h)
def fold(self, L, R): # [L,R)の区間取得
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
vL = self.monoid_identity
vR = self.monoid_identity
while L < R:
if L & 1:
vL = self.monoid_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.monoid_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.monoid_func(vL,vR)
#重たい
def operate_range(self,L,R,x): # [L,R)にxを作用
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
while L < R:
if L & 1:
self.lazy[L] = self.composition(self.lazy[L], x)
L += 1
if R & 1:
R -= 1
self.lazy[R] = self.composition(self.lazy[R], x)
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
def main():
def monoid_func(x,y):
return (x+y) % MOD
def composition(a,b):
b0,c0 = a
b1,c1 = b
return ((b0*b1) % MOD,(b1*c0+c1) % MOD)
def operate(x,a,r): # 右作用
b,c = a
return (b*x+c*r) % MOD
monoid_identity = 0
operator_identity = (1,0)
N, Q = LI()
A = LI()
LST = LazySegTree(A, monoid_func, composition, operate, monoid_identity, operator_identity)
for q in LIR(Q):
if q[0] == 0:
_, l, r, b, c = q
LST.operate_range(l,r,(b,c))
else:
_, l, r = q
print((LST.fold(l,r)))
if __name__ == '__main__':
main() | p02568 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(1000000)
# モノイドに対して適用可能、Nが2冪でなくても良い
class LazySegTree():
def __init__(self, initial_values, monoid_func, composition, operate, monoid_identity, operator_identity):
self.N = len(initial_values)
self.monoid_func = monoid_func
self.composition = composition
self.operate = operate
self.monoid_identity = monoid_identity
self.operator_identity = operator_identity
self.data = [self.monoid_identity]*(2*self.N)
self.lazy = [self.operator_identity]*(2*self.N)
self.size = [0]*(2*self.N)
for i, ai in enumerate(initial_values):
self.data[self.N+i] = ai
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
self.size[i] = self.size[i << 1] + self.size[i << 1 | 1]
def update(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.data[i] = x
while i>1:
i >>= 1
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.data[i],self.lazy[i],self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
while i > 1:
i >>= 1
self.data[i] = self.monoid_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.data[i] = self.operate(self.data[i],self.lazy[i],self.size[i])
self.lazy[i << 1] = self.composition(self.lazy[i << 1],self.lazy[i])
self.lazy[i << 1 | 1] = self.composition(self.lazy[i << 1 | 1], self.lazy[i])
self.lazy[i] = self.operator_identity
def propagate_above(self,i): # i番目より上で作用を施す
H = i.bit_length()
for h in range(H,0,-1):
self.propagate_at(i >> h)
def fold(self, L, R): # [L,R)の区間取得
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
vL = self.monoid_identity
vR = self.monoid_identity
while L < R:
if L & 1:
vL = self.monoid_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.monoid_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.monoid_func(vL,vR)
#重たい
def apply_range(self,L,R,x): # [L,R)にxを作用
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
while L < R:
if L & 1:
self.lazy[L] = self.composition(self.lazy[L], x)
L += 1
if R & 1:
R -= 1
self.lazy[R] = self.composition(self.lazy[R], x)
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
def monoid_func(x,y):
return (x+y) % MOD
def composition(a,b):
b0,c0 = a
b1,c1 = b
return ((b0*b1) % MOD,(b1*c0+c1) % MOD)
def operate(x,a,r):
b,c = a
return (b*x+c*r) % MOD
def main():
monoid_identity = 0
operator_identity = (1,0)
N, Q = LI()
A = LI()
LST = LazySegTree(A, monoid_func, composition, operate, monoid_identity, operator_identity)
for q in LIR(Q):
if q[0] == 0:
_, l, r, b, c = q
LST.apply_range(l,r,(b,c))
else:
_, l, r = q
print((LST.fold(l,r)))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(1000000)
# モノイドに対して適用可能、Nが2冪でなくても良い
class LazySegTree():
def __init__(self, initial_values, monoid_func, composition, operate, monoid_identity, operator_identity):
self.N = len(initial_values)
self.monoid_func = monoid_func
self.composition = composition
self.operate = operate
self.monoid_identity = monoid_identity
self.operator_identity = operator_identity
self.data = [self.monoid_identity]*(2*self.N)
self.lazy = [self.operator_identity]*(2*self.N)
self.size = [0]*(2*self.N)
for i, ai in enumerate(initial_values):
self.data[self.N+i] = ai
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
self.size[i] = self.size[i << 1] + self.size[i << 1 | 1]
def update(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.data[i] = x
while i>1:
i >>= 1
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.lazy[i], self.data[i], self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
while i > 1:
i >>= 1
self.data[i] = self.monoid_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.data[i] = self.operate(self.lazy[i], self.data[i], self.size[i])
self.lazy[i << 1] = self.composition(self.lazy[i], self.lazy[i << 1])
self.lazy[i << 1 | 1] = self.composition(self.lazy[i], self.lazy[i << 1 | 1])
self.lazy[i] = self.operator_identity
def propagate_above(self,i): # i番目より上で作用を施す
H = i.bit_length()
for h in range(H,0,-1):
self.propagate_at(i >> h)
def fold(self, L, R): # [L,R)の区間取得
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
vL = self.monoid_identity
vR = self.monoid_identity
while L < R:
if L & 1:
vL = self.monoid_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.monoid_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.monoid_func(vL,vR)
#重たい
def apply_range(self,L,R,x): # [L,R)にxを作用
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
while L < R:
if L & 1:
self.lazy[L] = self.composition(x, self.lazy[L])
L += 1
if R & 1:
R -= 1
self.lazy[R] = self.composition(x, self.lazy[R])
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
# shift = 1 << 32
# mask = (1 << 32) - 1
def monoid_func(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
#なんかここおかしい
def operate(f, a, _):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def main():
monoid_identity = 0
operator_identity = 1 << 32
N, Q = LI()
A = [(ai << 32) + 1 for ai in LI()]
LST = LazySegTree(A, monoid_func, composition, operate, monoid_identity, operator_identity)
for q in LIR(Q):
if q[0] == 0:
_, l, r, b, c = q
LST.apply_range(l,r,(b<<32)+c)
else:
_, l, r = q
print((LST.fold(l,r) >> 32))
if __name__ == '__main__':
main() | p02568 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(1000000)
# モノイドに対して適用可能、Nが2冪でなくても良い
class LazySegTree():
def __init__(self, initial_values, monoid_func, composition, operate, monoid_identity, operator_identity):
self.N = len(initial_values)
self.monoid_func = monoid_func
self.composition = composition
self.operate = operate
self.monoid_identity = monoid_identity
self.operator_identity = operator_identity
self.data = [self.monoid_identity]*(2*self.N)
self.lazy = [self.operator_identity]*(2*self.N)
self.size = [0]*(2*self.N)
for i, ai in enumerate(initial_values):
self.data[self.N+i] = ai
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
self.size[i] = self.size[i << 1] + self.size[i << 1 | 1]
def update(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.data[i] = x
while i>1:
i >>= 1
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.lazy[i], self.data[i], self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
while i > 1:
i >>= 1
self.data[i] = self.monoid_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.data[i] = self.operate(self.lazy[i], self.data[i], self.size[i])
self.lazy[i << 1] = self.composition(self.lazy[i], self.lazy[i << 1])
self.lazy[i << 1 | 1] = self.composition(self.lazy[i], self.lazy[i << 1 | 1])
self.lazy[i] = self.operator_identity
def propagate_above(self,i): # i番目より上で作用を施す
H = i.bit_length()
for h in range(H,0,-1):
self.propagate_at(i >> h)
def fold(self, L, R): # [L,R)の区間取得
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
vL = self.monoid_identity
vR = self.monoid_identity
while L < R:
if L & 1:
vL = self.monoid_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.monoid_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.monoid_func(vL,vR)
#重たい
def apply_range(self,L,R,x): # [L,R)にxを作用
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
while L < R:
if L & 1:
self.lazy[L] = self.composition(x, self.lazy[L])
L += 1
if R & 1:
R -= 1
self.lazy[R] = self.composition(x, self.lazy[R])
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
# shift = 1 << 32
# mask = (1 << 32) - 1
def monoid_func(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gc * fb + fc) % MOD)
#なんかここおかしい
def operate(f, a, _):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def main():
monoid_identity = 0
operator_identity = 1 << 32
N, Q = LI()
A = [(ai << 32) + 1 for ai in LI()]
LST = LazySegTree(A, monoid_func, composition, operate, monoid_identity, operator_identity)
for q in LIR(Q):
if q[0] == 0:
_, l, r, b, c = q
LST.apply_range(l,r,(b<<32)+c)
else:
_, l, r = q
print((LST.fold(l,r) >> 32))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if len(args) > 0 else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 998244353
INF = float("inf")
sys.setrecursionlimit(1000000)
# モノイドに対して適用可能、Nが2冪でなくても良い
#
class LazySegTree():
def __init__(self, initial_values, monoid_func, composition, operate, monoid_identity, operator_identity):
self.N = len(initial_values)
self.monoid_func = monoid_func
self.composition = composition # composition(f, g) => g(f(x))の順であることに注意
self.operate = operate #右作用 operate(a, f) => f(a), 雑に可換な処理を書こうとするとバグるので注意
self.monoid_identity = monoid_identity
self.operator_identity = operator_identity
self.data = [self.monoid_identity]*(2*self.N)
self.lazy = [self.operator_identity]*(2*self.N)
self.size = [0]*(2*self.N)
for i, ai in enumerate(initial_values):
self.data[self.N+i] = ai
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
self.size[i] = self.size[i << 1] + self.size[i << 1 | 1]
def update(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.data[i] = x
while i>1:
i >>= 1
self.data[i] = self.monoid_func(self.data[i << 1], self.data[i << 1 | 1])
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.data[i],self.lazy[i],self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
while i > 1:
i >>= 1
self.data[i] = self.monoid_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.data[i] = self.operate(self.data[i],self.lazy[i],self.size[i])
self.lazy[i << 1] = self.composition(self.lazy[i << 1],self.lazy[i])
self.lazy[i << 1 | 1] = self.composition(self.lazy[i << 1 | 1], self.lazy[i])
self.lazy[i] = self.operator_identity
def propagate_above(self,i): # i番目より上で作用を施す
H = i.bit_length()
for h in range(H,0,-1):
self.propagate_at(i >> h)
def fold(self, L, R): # [L,R)の区間取得
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
vL = self.monoid_identity
vR = self.monoid_identity
while L < R:
if L & 1:
vL = self.monoid_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.monoid_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.monoid_func(vL,vR)
#重たい
def apply_range(self,L,R,x): # [L,R)にxを作用
L += self.N
R += self.N
L0 = L // (L & -L)
R0 = R // (R & -R) - 1
self.propagate_above(L0)
self.propagate_above(R0)
while L < R:
if L & 1:
self.lazy[L] = self.composition(self.lazy[L], x)
L += 1
if R & 1:
R -= 1
self.lazy[R] = self.composition(self.lazy[R], x)
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
# shift = 1 << 32
# mask = (1 << 32) - 1
def monoid_func(s, t):
sv, sn = s >> 32, s % (1 << 32)
tv, tn = t >> 32, t % (1 << 32)
return (((sv + tv) % MOD) << 32) + sn + tn
# g(f(x))の順であることに注意
def composition(f, g):
fb, fc = f >> 32, f % (1 << 32)
gb, gc = g >> 32, g % (1 << 32)
return ((fb * gb % MOD) << 32) + ((gb * fc + gc) % MOD)
#右作用
#雑に可換な処理を書こうとするとバグるので注意
def operate(a,f,_):
fb, fc = f >> 32, f % (1 << 32)
av, an = a >> 32, a % (1 << 32)
return (((fb * av + fc * an) % MOD) << 32) + an
def main():
monoid_identity = 0
operator_identity = 1 << 32
N, Q = LI()
A = [(ai << 32) + 1 for ai in LI()]
LST = LazySegTree(A, monoid_func, composition, operate, monoid_identity, operator_identity)
for q in LIR(Q):
if q[0] == 0:
_, l, r, b, c = q
LST.apply_range(l,r,(b<<32)+c)
else:
_, l, r = q
print((LST.fold(l,r) >> 32))
if __name__ == '__main__':
main() | p02568 |
class LazySegmentTree():
__slots__ = ["n","num","merge","merge_unit","operate","merge_operate","operate_unit","data","lazy","count"]
def __init__(self,n,init,merge,merge_unit,operate,merge_operate,operate_unit):
self.merge=merge
self.merge_unit=merge_unit
self.operate=operate
self.merge_operate=merge_operate
self.operate_unit=operate_unit
self.n=(n-1).bit_length()
self.num = 1<<self.n
self.data=[merge_unit for i in range(1<<(self.n+1))]
self.lazy=[operate_unit for i in range(1<<(self.n+1))]
self.count = [1]*2*self.num
if init:
for i in range(n):
self.data[2**self.n+i]=init[i]
self.count[2**self.n+i]=1
for i in range(2**self.n-1,0,-1):
self.data[i]=self.merge(self.data[2*i],self.data[2*i+1])
self.count[i]=self.count[2*i]+self.count[2*i+1]
def update(self,l,r,x):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.count[2*v],self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.count[2*v+1],self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.count[2*v],self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.count[2*v+1],self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
while l<r:
if l&1:
self.data[l]=self.operate(self.count[l],self.data[l],x)
self.lazy[l]=self.merge_operate(self.lazy[l],x)
l+=1
if r&1:
self.data[r-1]=self.operate(self.count[r-1],self.data[r-1],x)
self.lazy[r-1]=self.merge_operate(self.lazy[r-1],x)
l>>=1
r>>=1
while l0:
l0>>=1
self.data[l0]=self.operate(self.count[l0],self.merge(self.data[2*l0],self.data[2*l0+1]),self.lazy[l0])
while r0:
r0>>=1
self.data[r0]=self.operate(self.count[r0],self.merge(self.data[2*r0],self.data[2*r0+1]),self.lazy[r0])
def query(self,l,r):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.count[2*v],self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.count[2*v+1],self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.count[2*v],self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.count[2*v+1],self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
res=self.merge_unit
while l<r:
if l&1:
res=self.merge(res,self.data[l])
l+=1
if r&1:
res=self.merge(res,self.data[r-1])
l>>=1
r>>=1
return res
import sys
input = sys.stdin.readline
mod = 998244353
merge = lambda x,y:(x+y) % mod
merge_unit = 0
operate = lambda L,x,y:(y[0]*x+y[1]*L) % mod
merge_operate = lambda x,y:(x[0]*y[0] % mod,(x[1]*y[0]+y[1])%mod)
operate_unit = (1,0)
N,Q = list(map(int,input().split()))
a = list(map(int,input().split()))
LST = LazySegmentTree(N,a,merge,merge_unit,operate,merge_operate,operate_unit)
for _ in range(Q):
query = list(map(int,input().split()))
if query[0] == 0:
gomi,l,r,b,c = query
LST.update(l,r,(b,c))
else:
gomi,l,r = query
print((LST.query(l,r))) | class LazySegmentTree():
__slots__ = ["n","num","merge","merge_unit","operate","merge_operate","operate_unit","data","lazy","count"]
def __init__(self,n,init,merge,merge_unit,operate,merge_operate,operate_unit):
self.merge=merge
self.merge_unit=merge_unit
self.operate=operate
self.merge_operate=merge_operate
self.operate_unit=operate_unit
self.n=(n-1).bit_length()
self.num = 1<<self.n
self.data=[merge_unit for i in range(1<<(self.n+1))]
self.lazy=[operate_unit for i in range(1<<(self.n+1))]
self.count = [1]*2*self.num
if init:
for i in range(n):
self.data[2**self.n+i]=init[i]
self.count[2**self.n+i]=1
for i in range(2**self.n-1,0,-1):
self.data[i]=self.merge(self.data[2*i],self.data[2*i+1])
self.count[i]=self.count[2*i]+self.count[2*i+1]
def update(self,l,r,x):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
while l<r:
if l&1:
self.data[l]=self.operate(self.data[l],x)
self.lazy[l]=self.merge_operate(self.lazy[l],x)
l+=1
if r&1:
self.data[r-1]=self.operate(self.data[r-1],x)
self.lazy[r-1]=self.merge_operate(self.lazy[r-1],x)
l>>=1
r>>=1
while l0:
l0>>=1
self.data[l0]=self.operate(self.merge(self.data[2*l0],self.data[2*l0+1]),self.lazy[l0])
while r0:
r0>>=1
self.data[r0]=self.operate(self.merge(self.data[2*r0],self.data[2*r0+1]),self.lazy[r0])
def query(self,l,r):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
res=self.merge_unit
while l<r:
if l&1:
res=self.merge(res,self.data[l])
l+=1
if r&1:
res=self.merge(res,self.data[r-1])
l>>=1
r>>=1
return res>>20
import sys
input = sys.stdin.buffer.readline
mod = 998244353
mask = 2**20 - 1
def merge(x,y):
s = ((x>>20) + (y>>20)) % mod
num = (x&mask) + (y&mask)
return (s<<20) + num
merge_unit = 0
def operate(x,ope):
s,num = x>>20,x&mask
s = (ope[0]*s + ope[1]*num) % mod
return (s<<20)+num
merge_operate = lambda x,y:(x[0]*y[0] % mod,(x[1]*y[0]+y[1])%mod)
operate_unit = (1,0)
N,Q = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [(a[i]<<20)+1 for i in range(N)]
LST = LazySegmentTree(N,a,merge,merge_unit,operate,merge_operate,operate_unit)
for _ in range(Q):
query = list(map(int,input().split()))
if query[0] == 0:
gomi,l,r,b,c = query
LST.update(l,r,(b,c))
else:
gomi,l,r = query
print((LST.query(l,r))) | p02568 |
class LazySegmentTree():
__slots__ = ["n","num","merge","merge_unit","operate","merge_operate","operate_unit","data","lazy","count"]
def __init__(self,n,init,merge,merge_unit,operate,merge_operate,operate_unit):
self.merge=merge
self.merge_unit=merge_unit
self.operate=operate
self.merge_operate=merge_operate
self.operate_unit=operate_unit
self.n=(n-1).bit_length()
self.num = 1<<self.n
self.data=[merge_unit for i in range(1<<(self.n+1))]
self.lazy=[operate_unit for i in range(1<<(self.n+1))]
self.count = [1]*2*self.num
if init:
for i in range(n):
self.data[2**self.n+i]=init[i]
self.count[2**self.n+i]=1
for i in range(2**self.n-1,0,-1):
self.data[i]=self.merge(self.data[2*i],self.data[2*i+1])
self.count[i]=self.count[2*i]+self.count[2*i+1]
def update(self,l,r,x):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
while l<r:
if l&1:
self.data[l]=self.operate(self.data[l],x)
self.lazy[l]=self.merge_operate(self.lazy[l],x)
l+=1
if r&1:
self.data[r-1]=self.operate(self.data[r-1],x)
self.lazy[r-1]=self.merge_operate(self.lazy[r-1],x)
l>>=1
r>>=1
while l0:
l0>>=1
self.data[l0]=self.operate(self.merge(self.data[2*l0],self.data[2*l0+1]),self.lazy[l0])
while r0:
r0>>=1
self.data[r0]=self.operate(self.merge(self.data[2*r0],self.data[2*r0+1]),self.lazy[r0])
def query(self,l,r):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
ope = self.lazy[v]
if ope == self.operate_unit:
continue
self.lazy[v]=self.operate_unit
self.data[2*v]=self.operate(self.data[2*v],ope)
self.data[2*v+1]=self.operate(self.data[2*v+1],ope)
self.lazy[2*v]=self.merge_operate(self.lazy[2*v],ope)
self.lazy[2*v+1]=self.merge_operate(self.lazy[2*v+1],ope)
res=self.merge_unit
while l<r:
if l&1:
res=self.merge(res,self.data[l])
l+=1
if r&1:
res=self.merge(res,self.data[r-1])
l>>=1
r>>=1
return res>>20
import sys
input = sys.stdin.buffer.readline
mod = 998244353
mask = 2**20 - 1
def merge(x,y):
s = ((x>>20) + (y>>20)) % mod
num = (x&mask) + (y&mask)
return (s<<20) + num
merge_unit = 0
def operate(x,ope):
s,num = x>>20,x&mask
s = (ope[0]*s + ope[1]*num) % mod
return (s<<20)+num
merge_operate = lambda x,y:(x[0]*y[0] % mod,(x[1]*y[0]+y[1])%mod)
operate_unit = (1,0)
N,Q = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [(a[i]<<20)+1 for i in range(N)]
LST = LazySegmentTree(N,a,merge,merge_unit,operate,merge_operate,operate_unit)
for _ in range(Q):
query = list(map(int,input().split()))
if query[0] == 0:
gomi,l,r,b,c = query
LST.update(l,r,(b,c))
else:
gomi,l,r = query
print((LST.query(l,r))) | class LazySegmentTree():
__slots__ = ["n","num","merge","merge_unit","operate","merge_operate","operate_unit","data","lazy","count"]
def __init__(self,n,init,merge,merge_unit,operate,merge_operate,operate_unit):
self.merge=merge
self.merge_unit=merge_unit
self.operate=operate
self.merge_operate=merge_operate
self.operate_unit=operate_unit
self.n=(n-1).bit_length()
self.num = 1<<self.n
self.data=[merge_unit for i in range(1<<(self.n+1))]
self.lazy=[operate_unit for i in range(1<<(self.n+1))]
if init:
for i in range(n):
self.data[2**self.n+i]=init[i]
for i in range(2**self.n-1,0,-1):
self.data[i]=self.merge(self.data[2*i],self.data[2*i+1])
def update(self,l,r,x):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
self.data[v] = self.operate(self.data[v],self.lazy[v])
self.lazy[v<<1]=self.merge_operate(self.lazy[v<<1],self.lazy[v])
self.lazy[(v<<1)+1]=self.merge_operate(self.lazy[(v<<1)+1],self.lazy[v])
self.lazy[v]=self.operate_unit
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
self.data[v] = self.operate(self.data[v],self.lazy[v])
self.lazy[v<<1]=self.merge_operate(self.lazy[v<<1],self.lazy[v])
self.lazy[(v<<1)+1]=self.merge_operate(self.lazy[(v<<1)+1],self.lazy[v])
self.lazy[v]=self.operate_unit
while l<r:
if l&1:
self.lazy[l]=self.merge_operate(self.lazy[l],x)
l+=1
if r&1:
self.lazy[r-1]=self.merge_operate(self.lazy[r-1],x)
l>>=1
r>>=1
while l0:
l0>>=1
self.data[l0] = self.merge(self.operate(self.data[l0<<1],self.lazy[l0<<1]),self.operate(self.data[(l0<<1)+1],self.lazy[(l0<<1)+1]))
while r0:
r0>>=1
self.data[r0] = self.merge(self.operate(self.data[r0<<1],self.lazy[r0<<1]),self.operate(self.data[(r0<<1)+1],self.lazy[(r0<<1)+1]))
def query(self,l,r):
l+=1<<self.n
r+=1<<self.n
l0=l//(l&-l)
r0=r//(r&-r)-1
i = l0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
self.data[v] = self.operate(self.data[v],self.lazy[v])
self.lazy[v<<1]=self.merge_operate(self.lazy[v<<1],self.lazy[v])
self.lazy[(v<<1)+1]=self.merge_operate(self.lazy[(v<<1)+1],self.lazy[v])
self.lazy[v]=self.operate_unit
i = r0
m=i.bit_length()-1
for bit in range(m,0,-1):
v=i>>bit
self.data[v] = self.operate(self.data[v],self.lazy[v])
self.lazy[v<<1]=self.merge_operate(self.lazy[v<<1],self.lazy[v])
self.lazy[(v<<1)+1]=self.merge_operate(self.lazy[(v<<1)+1],self.lazy[v])
self.lazy[v]=self.operate_unit
res=self.merge_unit
while l<r:
if l&1:
res = self.merge(res,self.operate(self.data[l],self.lazy[l]))
l+=1
if r&1:
res = self.merge(res,self.operate(self.data[r-1],self.lazy[r-1]))
l>>=1
r>>=1
return res>>32
import sys
input = sys.stdin.buffer.readline
mod = 998244353
mask = 2**32 - 1
def merge(x,y):
s = ((x>>32) + (y>>32)) % mod
num = (x&mask) + (y&mask)
return (s<<32) + num
merge_unit = 0
def operate(x,ope):
s,num = x>>32,x&mask
b,c = ope>>32,ope&mask
s = (b*s + c*num) % mod
return (s<<32)+num
def merge_operate(x,y):
b1,c1 = x>>32,x&mask
b2,c2 = y>>32,y&mask
return (((b1*b2)%mod)<<32)+((b2*c1+c2)%mod)
operate_unit = 1<<32
N,Q = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [(a[i]<<32)+1 for i in range(N)]
LST = LazySegmentTree(N,a,merge,merge_unit,operate,merge_operate,operate_unit)
for _ in range(Q):
query = list(map(int,input().split()))
if query[0] == 0:
gomi,l,r,b,c = query
LST.update(l,r,(b<<32)+c)
else:
gomi,l,r = query
print((LST.query(l,r))) | p02568 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 998244353; INF = float("inf")
sec = pow(2, mod - 2, mod)
# 5 3
# 1 1 1 1 1
# 0 0 4 10 3
# 0 1 5 20 3
# 1 2 3
def getlist():
return list(map(int, input().split()))
class lazySegTree(object):
# N:処理する区間の長さ
def __init__(self, N):
self.N = N
self.LV = (N - 1).bit_length()
self.N0 = 2 ** self.LV
self.initVal = 0
self.data = [0] * (2 * self.N0)
self.lazybeta = [1] * (2 * self.N0)
self.lazy = [0] * (2 * self.N0)
def calc(self, a, b):
return a + b
def initialize(self, A):
for i in range(self.N):
self.data[self.N0 - 1 + i] = A[i]
for i in range(self.N0 - 2, -1, -1):
self.data[i] = self.calc(self.data[2 * i + 1], self.data[2 * i + 2])
def gindex(self, l, r):
L = (l + self.N0) >> 1; R = (r + self.N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
def propagates(self, *ids):
for i in reversed(ids):
w = self.lazybeta[i - 1]
v = self.lazy[i - 1]
if w == 1 and (not v):
continue
val = (v * sec) % mod
self.lazybeta[2 * i - 1] = (self.lazybeta[2 * i - 1] * w) % mod
self.lazybeta[2 * i] = (self.lazybeta[2 * i] * w) % mod
self.lazy[2 * i - 1] = (self.lazy[2 * i - 1] * w + val) % mod
self.lazy[2 * i] = (self.lazy[2 * i] * w + val) % mod
self.data[2 * i - 1] = (self.data[2 * i - 1] * w + val) % mod
self.data[2 * i] = (self.data[2 * i] * w + val) % mod
self.lazybeta[i - 1] = 1; self.lazy[i - 1] = 0
def update(self, l, r, b, c):
# 1行にまとめてよい？
*ids, = self.gindex(l, r + 1)
self.propagates(*ids)
L = self.N0 + l; R = self.N0 + r + 1
v = c
w = b
while L < R:
if R & 1:
R -= 1
self.lazybeta[R - 1] *= w; self.lazy[R - 1] = (w * self.lazy[R - 1] + v) % mod
self.data[R - 1] = (self.data[R - 1] * w + v) % mod
if L & 1:
self.lazybeta[L - 1] *= w; self.lazy[L - 1] = (w * self.lazy[L - 1] + v) % mod
self.data[L - 1] = (self.data[L - 1] * w + v) % mod
L += 1
L >>= 1; R >>= 1; v <<= 1
for i in ids:
self.data[i - 1] = self.calc(self.data[2 * i - 1], self.data[2 * i])
def query(self, l, r):
self.propagates(*self.gindex(l, r + 1))
L = self.N0 + l; R = self.N0 + r + 1
s = self.initVal
while L < R:
if R & 1:
R -= 1
s = self.calc(s, self.data[R - 1])
if L & 1:
s = self.calc(s, self.data[L - 1])
L += 1
L >>= 1; R >>= 1
return s
def main():
N, Q = getlist()
A = getlist()
lSeg = lazySegTree(N)
lSeg.initialize(A)
for _ in range(Q):
q = getlist()
if q[0] == 0:
null, l, r, b, c = q
lSeg.update(l, r - 1, b, c)
else:
null, l, r = q
res = lSeg.query(l, r - 1)
print((res % mod))
# print(lSeg.data)
# print(lSeg.lazybeta)
# print(lSeg.lazy)
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 998244353; INF = float("inf")
sec = pow(2, mod - 2, mod)
def getlist():
return list(map(int, input().split()))
class lazySegTree(object):
# N:処理する区間の長さ
def __init__(self, N):
self.N = N
self.LV = (N - 1).bit_length()
self.N0 = 2 ** self.LV
self.data = [0] * (2 * self.N0)
self.lazybeta = [1] * (2 * self.N0)
self.lazy = [0] * (2 * self.N0)
def initialize(self, A):
for i in range(self.N):
self.data[self.N0 - 1 + i] = A[i]
for i in range(self.N0 - 2, -1, -1):
self.data[i] = self.data[2 * i + 1] + self.data[2 * i + 2]
def gindex(self, l, r):
L = (l + self.N0) >> 1; R = (r + self.N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
def propagates(self, *ids):
for i in reversed(ids):
w = self.lazybeta[i - 1]
v = self.lazy[i - 1]
if w == 1 and (not v):
continue
val = (v * sec) % mod
self.lazybeta[2 * i - 1] = (self.lazybeta[2 * i - 1] * w) % mod
self.lazybeta[2 * i] = (self.lazybeta[2 * i] * w) % mod
self.lazy[2 * i - 1] = (self.lazy[2 * i - 1] * w + val) % mod
self.lazy[2 * i] = (self.lazy[2 * i] * w + val) % mod
self.data[2 * i - 1] = (self.data[2 * i - 1] * w + val) % mod
self.data[2 * i] = (self.data[2 * i] * w + val) % mod
self.lazybeta[i - 1] = 1; self.lazy[i - 1] = 0
def update(self, l, r, b, c):
*ids, = self.gindex(l, r + 1)
self.propagates(*ids)
L = self.N0 + l; R = self.N0 + r + 1
v = c; w = b
while L < R:
if R & 1:
R -= 1
self.lazybeta[R - 1] = (self.lazybeta[R - 1] * w) % mod
self.lazy[R - 1] = (w * self.lazy[R - 1] + v) % mod
self.data[R - 1] = (self.data[R - 1] * w + v) % mod
if L & 1:
self.lazybeta[L - 1] = (self.lazybeta[L - 1] * w) % mod
self.lazy[L - 1] = (w * self.lazy[L - 1] + v) % mod
self.data[L - 1] = (self.data[L - 1] * w + v) % mod
L += 1
L >>= 1; R >>= 1; v <<= 1
for i in ids:
self.data[i - 1] = (self.data[2 * i - 1] + self.data[2 * i]) % mod
def query(self, l, r):
self.propagates(*self.gindex(l, r + 1))
L = self.N0 + l; R = self.N0 + r + 1
s = 0
while L < R:
if R & 1:
R -= 1
s += self.data[R - 1]
if L & 1:
s += self.data[L - 1]
L += 1
L >>= 1; R >>= 1
s %= mod
return s
def main():
N, Q = getlist()
A = getlist()
lSeg = lazySegTree(N)
lSeg.initialize(A)
for _ in range(Q):
q = getlist()
if q[0] == 0:
null, l, r, b, c = q
lSeg.update(l, r - 1, b, c)
else:
null, l, r = q
res = lSeg.query(l, r - 1)
print(res)
if __name__ == '__main__':
main()
# 5 3
# 1 1 1 1 1
# 0 0 4 10 3
# 0 1 5 20 3
# 1 2 3 | p02568 |
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 998244353; INF = float("inf")
sec = pow(2, mod - 2, mod)
def getlist():
return list(map(int, input().split()))
class lazySegTree(object):
# N:処理する区間の長さ
def __init__(self, N):
self.N = N
self.LV = (N - 1).bit_length()
self.N0 = 2 ** self.LV
self.data = [0] * (2 * self.N0)
self.lazybeta = [1] * (2 * self.N0)
self.lazy = [0] * (2 * self.N0)
def initialize(self, A):
for i in range(self.N):
self.data[self.N0 - 1 + i] = A[i]
for i in range(self.N0 - 2, -1, -1):
self.data[i] = self.data[2 * i + 1] + self.data[2 * i + 2]
def gindex(self, l, r):
L = (l + self.N0) >> 1; R = (r + self.N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
def propagates(self, *ids):
for i in reversed(ids):
w = self.lazybeta[i - 1]
v = self.lazy[i - 1]
if w == 1 and (not v):
continue
val = (v * sec) % mod
self.lazybeta[2 * i - 1] = (self.lazybeta[2 * i - 1] * w) % mod
self.lazybeta[2 * i] = (self.lazybeta[2 * i] * w) % mod
self.lazy[2 * i - 1] = (self.lazy[2 * i - 1] * w + val) % mod
self.lazy[2 * i] = (self.lazy[2 * i] * w + val) % mod
self.data[2 * i - 1] = (self.data[2 * i - 1] * w + val) % mod
self.data[2 * i] = (self.data[2 * i] * w + val) % mod
self.lazybeta[i - 1] = 1; self.lazy[i - 1] = 0
def update(self, l, r, b, c):
*ids, = self.gindex(l, r + 1)
self.propagates(*ids)
L = self.N0 + l; R = self.N0 + r + 1
v = c; w = b
while L < R:
if R & 1:
R -= 1
self.lazybeta[R - 1] = (self.lazybeta[R - 1] * w) % mod
self.lazy[R - 1] = (w * self.lazy[R - 1] + v) % mod
self.data[R - 1] = (self.data[R - 1] * w + v) % mod
if L & 1:
self.lazybeta[L - 1] = (self.lazybeta[L - 1] * w) % mod
self.lazy[L - 1] = (w * self.lazy[L - 1] + v) % mod
self.data[L - 1] = (self.data[L - 1] * w + v) % mod
L += 1
L >>= 1; R >>= 1; v <<= 1
for i in ids:
self.data[i - 1] = (self.data[2 * i - 1] + self.data[2 * i]) % mod
def query(self, l, r):
self.propagates(*self.gindex(l, r + 1))
L = self.N0 + l; R = self.N0 + r + 1
s = 0
while L < R:
if R & 1:
R -= 1
s += self.data[R - 1]
if L & 1:
s += self.data[L - 1]
L += 1
L >>= 1; R >>= 1
s %= mod
return s
def main():
N, Q = getlist()
A = getlist()
lSeg = lazySegTree(N)
lSeg.initialize(A)
for _ in range(Q):
q = getlist()
if q[0] == 0:
null, l, r, b, c = q
lSeg.update(l, r - 1, b, c)
else:
null, l, r = q
res = lSeg.query(l, r - 1)
print(res)
if __name__ == '__main__':
main()
# 5 3
# 1 1 1 1 1
# 0 0 4 10 3
# 0 1 5 20 3
# 1 2 3 | import sys; input = sys.stdin.buffer.readline
mod = 998244353; INF = float("inf")
sec = pow(2, mod - 2, mod)
def getlist():
return list(map(int, input().split()))
class lazySegTree(object):
# N:処理する区間の長さ
def __init__(self, N):
self.N = N
self.LV = (N - 1).bit_length()
self.N0 = 2 ** self.LV
self.data = [0] * (2 * self.N0)
self.lazybeta = [1] * (2 * self.N0)
self.lazy = [0] * (2 * self.N0)
def initialize(self, A):
for i in range(self.N):
self.data[self.N0 - 1 + i] = A[i]
for i in range(self.N0 - 2, -1, -1):
self.data[i] =( self.data[2 * i + 1] + self.data[2 * i + 2]) % mod
def gindex(self, l, r):
L = (l + self.N0) >> 1; R = (r + self.N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
def propagates(self, *ids):
for i in reversed(ids):
w = self.lazybeta[i - 1]
v = self.lazy[i - 1]
if w == 1 and (not v):
continue
val = (v * sec) % mod
self.lazybeta[2 * i - 1] = (self.lazybeta[2 * i - 1] * w) % mod
self.lazybeta[2 * i] = (self.lazybeta[2 * i] * w) % mod
self.lazy[2 * i - 1] = (self.lazy[2 * i - 1] * w + val) % mod
self.lazy[2 * i] = (self.lazy[2 * i] * w + val) % mod
self.data[2 * i - 1] = (self.data[2 * i - 1] * w + val) % mod
self.data[2 * i] = (self.data[2 * i] * w + val) % mod
self.lazybeta[i - 1] = 1; self.lazy[i - 1] = 0
def update(self, l, r, b, c):
*ids, = self.gindex(l, r + 1)
self.propagates(*ids)
L = self.N0 + l; R = self.N0 + r + 1
v = c; w = b
while L < R:
if R & 1:
R -= 1
self.lazybeta[R - 1] = (self.lazybeta[R - 1] * w) % mod
self.lazy[R - 1] = (w * self.lazy[R - 1] + v) % mod
self.data[R - 1] = (self.data[R - 1] * w + v) % mod
if L & 1:
self.lazybeta[L - 1] = (self.lazybeta[L - 1] * w) % mod
self.lazy[L - 1] = (w * self.lazy[L - 1] + v) % mod
self.data[L - 1] = (self.data[L - 1] * w + v) % mod
L += 1
L >>= 1; R >>= 1; v <<= 1
for i in ids:
self.data[i - 1] = (self.data[2 * i - 1] + self.data[2 * i]) % mod
def query(self, l, r):
self.propagates(*self.gindex(l, r + 1))
L = self.N0 + l; R = self.N0 + r + 1
s = 0
while L < R:
if R & 1:
R -= 1
s += self.data[R - 1]
if L & 1:
s += self.data[L - 1]
L += 1
L >>= 1; R >>= 1
s %= mod
return s
def main():
N, Q = getlist()
A = getlist()
lSeg = lazySegTree(N)
lSeg.initialize(A)
for _ in range(Q):
q = getlist()
if q[0] == 0:
null, l, r, b, c = q
lSeg.update(l, r - 1, b, c)
else:
null, l, r = q
res = lSeg.query(l, r - 1)
print(res)
if __name__ == '__main__':
main()
# 5 3
# 1 1 1 1 1
# 0 0 4 10 3
# 0 1 5 20 3
# 1 2 3 | p02568 |
from typing import Callable, List, TypeVar
S = TypeVar("S") # モノイドの型
F = TypeVar("F") # 写像の型
class LazySegmentTree:
"""
Lazy Segment Tree from https://atcoder.jp/contests/practice2/submissions/16775176
References:
https://tumoiyorozu.github.io/single-file-ac-library/document_ja/lazysegtree.html
https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
"""
__slots__ = ["e", "op", "id", "mapping", "composition", "_n", "_log", "_size", "tree", "lazy"]
def __init__(self,
a: List[S],
e: S,
op: Callable[[S, S], S],
id_: F,
mapping: Callable[[F, S], S],
composition: Callable[[F, F], F]) -> None:
self.e = e
self.op = op
self.id = id_
self.mapping = mapping
self.composition = composition
self._n = len(a)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self.tree = [e] * self._size + a + [e] * (self._size - self._n)
for i in range(self._size - 1, 0, -1):
self._update(i)
self.lazy = [id_] * self._size
def _update(self, k: int) -> None:
"""Update the value of a[k]."""
self.tree[k] = self.op(self.tree[2 * k], self.tree[2 * k + 1])
def _apply_all(self, k: int, f: F) -> None:
self.tree[k] = self.mapping(f, self.tree[k])
if k < self._size:
self.lazy[k] = self.composition(f, self.lazy[k])
def _push(self, k: int) -> None:
self._apply_all(2 * k, self.lazy[k])
self._apply_all(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def set(self, k: int, x: S) -> None:
"""Assign x to a[k] in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = x
for i in range(1, self._log + 1):
self._update(k >> i)
def get(self, k: int) -> S:
"""Return a[k] in O(1)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
return self.tree[k]
def prod(self, l: int, r: int) -> S:
"""Return op(a[l], ..., a[r - 1]). Return e, if l == r.
Complexity: O(log n)
"""
assert 0 <= l <= r <= self._n
if l == r:
return self.e
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push(r >> i)
sml, smr = self.e, self.e
while l < r:
if l & 1:
sml = self.op(sml, self.tree[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.tree[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def prod_all(self) -> S:
"""Return op(a[0], ..., a[n - 1]. Return e if n == 0.
Complexity: O(1)
"""
return self.tree[1]
def apply(self, k: int, f: F) -> None:
"""Apply a[p] = op_st(a[p], x) in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = self.mapping(f, self.tree[k])
for i in range(1, self._log + 1):
self._update(k >> i)
def apply_range(self, l: int, r: int, f: F) -> None:
"""Apply a[i] = op_st(a[i], x) for all i = l..r-1 in O(log n)."""
assert 0 <= l <= r <= self._n
if l == r:
return
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push((r - 1) >> i)
l_tmp, r_tmp = l, r
while l < r:
if l & 1:
self._apply_all(l, f)
l += 1
if r & 1:
r -= 1
self._apply_all(r, f)
l >>= 1
r >>= 1
l, r = l_tmp, r_tmp
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)
mod = 998244353
def op(l, r):
return [(l[0] + r[0]) % mod, l[1] + r[1]]
def mapping(f, x):
return [(x[0] * f[0] + x[1] * f[1]) % mod, x[1]]
def composition(l, r):
return [(l[0] * r[0]) % mod, (r[1] * l[0] + l[1]) % mod]
N, Q = list(map(int, input().split()))
a = list(map(int, input().split()))
lst = LazySegmentTree([[v, 1] for v in a], [0, 0], op, [1, 0], mapping, composition)
for i in range(Q):
q, *p = list(map(int, input().split()))
if q == 0:
lst.apply_range(p[0], p[1], [p[2], p[3]])
else:
print((lst.prod(*p)[0]))
| from typing import Callable, List, TypeVar
S = TypeVar("S") # モノイドの型
F = TypeVar("F") # 写像の型
class LazySegmentTree:
"""
Lazy Segment Tree from https://atcoder.jp/contests/practice2/submissions/16775176
References:
https://tumoiyorozu.github.io/single-file-ac-library/document_ja/lazysegtree.html
https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
"""
__slots__ = ["e", "op", "id", "mapping", "composition", "_n", "_log", "_size", "tree", "lazy"]
def __init__(self,
a: List[S],
e: S,
op: Callable[[S, S], S],
id_: F,
mapping: Callable[[F, S], S],
composition: Callable[[F, F], F]) -> None:
self.e = e
self.op = op
self.id = id_
self.mapping = mapping
self.composition = composition
self._n = len(a)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self.tree = [e] * self._size + a + [e] * (self._size - self._n)
for i in range(self._size - 1, 0, -1):
self._update(i)
self.lazy = [id_] * self._size
def _update(self, k: int) -> None:
"""Update the value of a[k]."""
self.tree[k] = self.op(self.tree[2 * k], self.tree[2 * k + 1])
def _apply_all(self, k: int, f: F) -> None:
self.tree[k] = self.mapping(f, self.tree[k])
if k < self._size:
self.lazy[k] = self.composition(f, self.lazy[k])
def _push(self, k: int) -> None:
self._apply_all(2 * k, self.lazy[k])
self._apply_all(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def set(self, k: int, x: S) -> None:
"""Assign x to a[k] in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = x
for i in range(1, self._log + 1):
self._update(k >> i)
def get(self, k: int) -> S:
"""Return a[k] in O(1)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
return self.tree[k]
def prod(self, l: int, r: int) -> S:
"""Return op(a[l], ..., a[r - 1]). Return e, if l == r.
Complexity: O(log n)
"""
assert 0 <= l <= r <= self._n
if l == r:
return self.e
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push(r >> i)
sml, smr = self.e, self.e
while l < r:
if l & 1:
sml = self.op(sml, self.tree[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.tree[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def prod_all(self) -> S:
"""Return op(a[0], ..., a[n - 1]. Return e if n == 0.
Complexity: O(1)
"""
return self.tree[1]
def apply(self, k: int, f: F) -> None:
"""Apply a[p] = op_st(a[p], x) in O(log n)."""
assert 0 <= k < self._n
k += self._size
for i in range(self._log, 0, -1):
self._push(k >> i)
self.tree[k] = self.mapping(f, self.tree[k])
for i in range(1, self._log + 1):
self._update(k >> i)
def apply_range(self, l: int, r: int, f: F) -> None:
"""Apply a[i] = op_st(a[i], x) for all i = l..r-1 in O(log n)."""
assert 0 <= l <= r <= self._n
if l == r:
return
l += self._size
r += self._size
for i in range(self._log, 0, -1):
if ((l >> i) << i) != l:
self._push(l >> i)
if ((r >> i) << i) != r:
self._push((r - 1) >> i)
l_tmp, r_tmp = l, r
while l < r:
if l & 1:
self._apply_all(l, f)
l += 1
if r & 1:
r -= 1
self._apply_all(r, f)
l >>= 1
r >>= 1
l, r = l_tmp, r_tmp
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)
mod = 998244353
def op(l, r):
l1, l2 = l >> 32, l % (1 << 32)
r1, r2 = r >> 32, r % (1 << 32)
return (((l1 + r1) % mod) << 32) + l2 + r2
def mapping(f, x):
f1, f2 = f >> 32, f % (1 << 32)
x1, x2 = x >> 32, x % (1 << 32)
return (((f1 * x1 + f2 * x2) % mod) << 32) + x2
def composition(l, r):
l1, l2 = l >> 32, l % (1 << 32)
r1, r2 = r >> 32, r % (1 << 32)
return (((l1 * r1) % mod) << 32) + ((r2 * l1 + l2) % mod)
N, Q = list(map(int, input().split()))
a = list(map(int, input().split()))
lst = LazySegmentTree([(v << 32) + 1 for v in a], 0, op, 1 << 32, mapping, composition)
for i in range(Q):
q, *p = list(map(int, input().split()))
if q == 0:
lst.apply_range(p[0], p[1], (p[2] << 32) + p[3])
else:
print((lst.prod(*p) >> 32))
| p02568 |
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
P = 998244353
f = lambda x, y: (x + y) % P
g = lambda x, a, s: (a[0] * x + a[1] * s) % P
h = lambda a, b: (a[0] * b[0] % P, (a[1] * b[0] + b[1]) % P)
unitX = 0
unitA = (1, 0)
N, Q = list(map(int, input().split()))
A = [int(a) for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
q = [int(a) for a in input().split()]
if q[0] == 0:
l, r, b, c = q[1:]
st.operate_range(l, r, (b, c))
else:
l, r = q[1:]
print((st.getrange(l, r)))
| 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
P = 998244353
mm = 4294967295
f = lambda x, y: (x + y) % P
def g(x, a, s):
a1, a2 = a >> 32, a & mm
return (a1 * x + a2 * s) % P
def h(a, b):
a1, a2 = a >> 32, a & mm
b1, b2 = b >> 32, b & mm
return (a1 * b1 % P << 32) + (a2 * b1 + b2) % P
unitX = 0
unitA = 1 << 32
N, Q = list(map(int, input().split()))
A = [int(a) for a in input().split()]
st = LazySegmentTree(A, unitX, unitA, f, g, h)
for _ in range(Q):
q = [int(a) for a in input().split()]
if q[0] == 0:
l, r, b, c = q[1:]
st.operate_range(l, r, (b << 32) + c)
else:
l, r = q[1:]
print((st.getrange(l, r)))
| p02568 |
ref = "SCHD"
first = 0
while 1:
try:
n = eval(input())
if first: print()
first = 1
except:
break
P = [list(map(int,input().split())) for i in range(4)]
H = list(map(int,input().split()))
for _ in range(n):
hand = input().replace("A","1").replace("T","10").replace("J","11").replace("Q","12").replace("K","13").split()
num = [int(i[:-1]) for i in hand]
suit = [ref.index(i[-1]) for i in hand]
ans = sum(P[suit[i]][num[i]-1] for i in range(5))
if len(set(suit)) == 1:
if sorted(num) == [1,10,11,12,13]:
ans *= H[8]
elif sorted([i - min(num) for i in num]) == [0,1,2,3,4]:
ans *= H[7]
else:
ans *= H[4]
elif sorted([i - min(num) for i in num]) == [0,1,2,3,4] or sorted(num) == [1,10,11,12,13]:
ans *= H[3]
elif max(num.count(i) for i in set(num)) == 4:
ans *= H[6]
elif max(num.count(i) for i in set(num)) == 3:
if len(set(num)) == 2:
ans *= H[5]
else:
ans *= H[2]
elif max(num.count(i) for i in set(num)) == 2:
if len(set(num)) == 3:
ans *= H[1]
else:
ans *= H[0]
else:
ans = 0
print(ans) | ref = "SCHD"
first = 0
while 1:
try:
n = eval(input())
if first: print()
first = 1
except:
break
P = [list(map(int,input().split())) for i in range(4)]
H = list(map(int,input().split()))
for _ in range(n):
hand = input().replace("A","1").replace("T","10").replace("J","11").replace("Q","12").replace("K","13").split()
num = [int(i[:-1]) for i in hand]
suit = [ref.index(i[-1]) for i in hand]
ans = sum(P[suit[i]][num[i]-1] for i in range(5))
snum = sorted([i - min(num) for i in num])
same = max(num.count(i) for i in set(num))
if len(set(suit)) == 1:
if snum == [0,9,10,11,12]:
ans *= H[8]
elif snum == [0,1,2,3,4]:
ans *= H[7]
else:
ans *= H[4]
elif snum == [0,1,2,3,4] or snum == [0,9,10,11,12]:
ans *= H[3]
elif same == 4:
ans *= H[6]
elif same == 3:
if len(set(num)) == 2:
ans *= H[5]
else:
ans *= H[2]
elif same == 2:
if len(set(num)) == 3:
ans *= H[1]
else:
ans *= H[0]
else:
ans = 0
print(ans) | p01335 |
A, B, C, D, E, F = list(map(int, input().split(' ')))
water = []
for i in range(31):
if A*i >= F:
break
for j in range(16):
if 100 * (A*i + B*j) < F:
water.append(100*(A*i+B*j))
else:
break
water = sorted(list(set(water)))
sugar = []
for i in range(max(water)//100*E//C + 1):
for j in range(max(water)//100*E//D + 1):
temp_sugar = C*i + D*j
if temp_sugar + water[1] <= F:
sugar.append(temp_sugar)
else:
break
sugar = sorted(list(set(sugar)))
max_conc = 0
ans_W = 100*A
ans_sugar = 0
for W in water:
if W == 0:
continue
for S in sugar:
if S+W <= F and S <= W*E//100:
if max_conc < S/(W+S):
max_conc = S/(S+W)
ans_W = W
ans_sugar = S
else:
break
print(('{0} {1}'.format(ans_W+ans_sugar, ans_sugar)))
| A, B, C, D, E, F = list(map(int, input().split(' ')))
max_sugar = 0
max_water = 100*A
max_conc = 0.0
A_limit = F // (100*A)
for i in range(A_limit + 1):
B_limit = (F-100*A*i) // (100*B)
for j in range(B_limit + 1):
if i == 0 and j == 0:
continue
sugar_limit = min(E * (A*i+B*j), F-100*(A*i+B*j))
sugar_ = 0
for c in range(sugar_limit//C + 1):
d = (sugar_limit-c*C)//D
temp_sugar = c*C + d*D
sugar_ = max(sugar_, temp_sugar)
temp_conc = sugar_/(sugar_+100*(A*i+B*j))
if temp_conc > max_conc:
max_conc = temp_conc
max_water = 100*(A*i + B*j)
max_sugar = sugar_
print(('{0} {1}'.format(max_water+max_sugar, max_sugar)))
| p03601 |
N, A, B = list(map(int, input().split()))
x = N // (A + B)
ans = A * x
ans = ans + min(N - (A+B) * x, A)
print(ans) | N, A, B = list(map(int, input().split()))
st = N // (A+B)
plus = min(N%(A+B), A)
ans = A * st + plus
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
c = 0
for i in range(0, n//(a+b)):
c = a * (n//(a+b))
if n%(a+b) > a:
c += a
else:
c += n%(a+b)
print(c) | n, a, b = list(map(int, input().split()))
cycles = n//(a+b)
count = 0
count += a*cycles
rest = n - (a+b)*cycles
if rest > a:
count += a
else:
count += rest
print(count) | p02754 |
N, A, B = list(map(int, input().split(' ')))
blue = 0
if N!=0 and A!=0:
for i in range(int(N/(A+B))+1):
if i==int(N/(A+B)):
if N%(A+B) <= A:
blue += N%(A+B)
else:
blue += A
else:
blue += A
print(blue) | N, A, B = list(map(int, input().split(' ')))
blue = 0
if N!=0 and A!=0:
blue = A *int(N/(A+B))
if N%(A+B) <= A:
blue += N%(A+B)
else:
blue += A
print(blue) | p02754 |
n,b,r=list(map(int,input().split()));print(((n//(b+r))*b+min(b,n%(b+r)))) | n,b,r=list(map(int,input().split()));c=b+r;print(((n//c)*b+min(b,n%c))) | p02754 |
N, A, B = list(map(int, input().split()))
syou = N // (A + B)
mod = N % (A + B)
ans = A * syou
if (mod <= A):
ans += mod
else:
ans += A
print(ans) | N, A, B = list(map(int, input().split()))
syou = N // (A + B)
mod = N % (A + B)
ans = A * syou
ans += min(A, mod)
print(ans) | p02754 |
n,a,b = list(map(int, input().strip().split()))
t = n // (a+b)
s = n % (a+b)
if s > a:
print((t*a+a))
else:
print((t*a+s)) | n, a, b = list(map(int, input().split()))
ans = (n//(a+b)) * a
ans += n % (a+b) if ((n % (a+b)) <= a) else a
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
c = a + b
print((n // c * a + min(n % c, a)))
| n, a, b = list(map(int, input().split()))
b += a
print((n // b * a + min(n % b, a)))
| p02754 |
n,a,b = list(map(int, input().split(" ")))
Aball = ""
for i in range(a):
Aball+="b"
Bball = ""
for i in range(b):
Bball+="a"
t = ""
while len(t) <= n:
t+=Aball
if len(t)>n:
t = t[:n]
break
t+=Bball
if len(t)>n:
t = t[:n]
break
count = t.count("b")
print(count)
| n,a,b = list(map(int, input().split(" ")))
count = a*(n//(a+b))
add = n%(a+b)
if add < a:
count+=add
else:
count+=a
print(count) | p02754 |
n, a, b = list(map(int, input().split()))
l = list('')
while len(l) <= n:
for i in range(a):
l.append('blue')
for i in range(b):
l.append('red')
count = 0
for i in range(n):
if l[i] == 'blue':
count += 1
print(count) | n, a, b = list(map(int, input().split()))
mod = int(n % (a + b))
cycle = n // (a + b)
if mod == 0:
print((a * cycle))
elif mod > a:
print((a * cycle + a))
else:
print((a * cycle + mod)) | p02754 |
N, A, B = list(map(int, input().split()))
list=[]
m=0
def add(i,j):
while(i<A):
list.append("b")
i+=1
while(j<B):
list.append("r")
j+=1
while(m<N):
i=0
j=0
add(i,j)
m+=A
m+=B
l=list[0:N]
r=l.count("b")
print(r) | N, A, B = list(map(int, input().split()))
if(A==0 & B==0):
print("0")
else:
r=N//(A+B)
s=N%(A+B)
if(A<s):
s=A
if(A!=0):
t=(A*r)+s
else:
t=0
print(t) | p02754 |
N, b, r = list(map(int, input().split()))
str = ''
loop, cnt, bcnt = 0, 0, 0
while(cnt <= N):
if loop%2 == 0:
cnt += b
bcnt += b
if N - cnt < 0:
bcnt += (N-cnt)
elif loop%2 == 1:
cnt += r
loop += 1
print(bcnt) | N, b, r = list(map(int, input().split()))
if b==0 and r==0:
print((0))
exit()
c = N//(b+r)
if N%(b+r) == 0:
print((b*c))
else:
if N%(b+r) <= b:
print((c*b + N%(b+r)))
else:
print((b*c + b)) | p02754 |
# -*- coding: utf-8 -*-
N, A, B = input().split()
balls = []
bBalls = []
rBalls = []
for i in range(int(A)):
rBalls.append("b")
for i in range(int(B)):
rBalls.append("r")
answer = 0
isBreak = False
for i in range(10**100):
balls = bBalls + rBalls + balls
if( len(balls) > int(N) ) :
for c in range(int(N)):
if(balls[c] == "b") :
answer = answer +1
isBreak = True
isBreak = True
if( isBreak ) :
break
print(answer)
| # -*- coding: utf-8 -*-
N, A, B = list(map(int , input().split() ))
x = (N // (A + B)) * A
mod = N % (A + B)
if mod <= A :
z = mod
else :
z = A
print((x + z))
| p02754 |
n, a, b = list(map(int, input().split()))
acnt = 0
bcnt = 0
while True:
acnt += a
if acnt + bcnt >= n:
acnt -= (acnt + bcnt) - n
break
bcnt += b
if acnt + bcnt >= n:
break
print(acnt)
| n, a, b = list(map(int, input().split()))
amari = n % (a+b)
sho = n // (a+b)
if n <= a:
print(n)
elif amari == 0:
print((a*sho))
elif amari < a:
print((a*sho + amari))
else:
print((a*sho + a))
| p02754 |
n, a, b = list(map(int, input().split()))
amari = n % (a+b)
sho = n // (a+b)
if n <= a:
print(n)
elif amari == 0:
print((a*sho))
elif amari < a:
print((a*sho + amari))
else:
print((a*sho + a))
| n, a, b = list(map(int, input().split()))
amari = n % (a + b)
sho = n // (a + b)
if n <= a:
print(n)
else:
print((a * sho + min(a, amari)))
| p02754 |
n, a, b = list(map(int, input().split()))
ans = []
while (True):
for _ in range(a):
ans.append('b')
if len(ans) >= n:
break
for _ in range(b):
ans.append('r')
if len(ans) >= n:
break
print((ans[:n].count('b')))
| n, a, b = list(map(int, input().split()))
ans = (n//(a+b)) * a
if n % (a+b) > a:
print((ans + a))
else:
print((ans + n % (a+b)))
| p02754 |
# place A blue balls first,
# then place B red balls after
# go until you get to N
n, a, b = list(map(int, input().split()))
rmult = 0
bmult = 0
total = 0
it = 1
ended = ''
while n > total:
total += a
bmult += 1
ended = 'b'
if n > total:
total += b
rmult += 1
ended = 'r'
if ended == 'b':
numofb = a * bmult - (total - n)
else:
numofb = a * bmult
print(numofb)
| # place A blue balls first,
# then place B red balls after
# go until you get to N
n, a, b = list(map(int, input().split()))
x = max(n // (a + b) - 2, 1)
while a * x + b * x < n:
temp = a * x + b * x
x += 1
temp = a * x + b * x
if temp - b >= n:
temp = temp - b
endsWithA = True
else:
endsWithA = False
if endsWithA:
print((a * x - (temp - n)))
else:
print((a * x))
| p02754 |
# place A blue balls first,
# then place B red balls after
# go until you get to N
n, a, b = list(map(int, input().split()))
x = max(n // (a + b) - 2, 1)
while a * x + b * x < n:
temp = a * x + b * x
x += 1
temp = a * x + b * x
if temp - b >= n:
temp = temp - b
endsWithA = True
else:
endsWithA = False
if endsWithA:
print((a * x - (temp - n)))
else:
print((a * x))
| n, a, b = list(map(int, input().split()))
x = max(n // (a + b) - 2, 1)
while a * x + b * x < n:
temp = a * x + b * x
x += 1
temp = a * x + b * x
if temp - b >= n:
temp = temp - b
print((a * x - (temp - n)))
else:
print((a * x))
| p02754 |
x = input().split()
n = int(x[0])
a = int(x[1])
b = int(x[2])
boll_a = ''
boll_b = ''
count = ''
for j in range(0, a):
boll_a += 'b'
for k in range(0, b):
boll_b += 'r'
for i in range(0, n):
count += boll_a
count += boll_b
if len(count) >= n: break
c = 0
for i in count[:n]:
if i == 'b':
c += 1
print(c) | x = input().split()
n = int(x[0])
a = int(x[1])
b = int(x[2])
l = ''
boll_a = ''
boll_b = ''
for j in range(0, a):
boll_a += 'b'
for k in range(0, b):
boll_b += 'r'
while n >= len(l):
l += boll_a
l += boll_b
print((l[:n].count('b'))) | p02754 |
N,A,B=list(map(int,input().split()))
count=0
count_blue=0
while count<N-(A+B):
count_blue+=A
count+=A+B
if N-count<A:
count_blue+=N-count
else:
count_blue+=A
print(count_blue)
| N,A,B=list(map(int,input().split()))
x=N//(A+B)
y=N%(A+B)
if y<A:
print((A*x+y))
else:
print((A*x+A)) | p02754 |
N,A,B= input().split()
ans=0
for i in range(int(N)):
if i%(int(A)+int(B))<int(A):
ans+=1
print(ans)
| N, A, B = [int(x) for x in input().strip().split()]
p = N // (A + B) * A
q = N % (A + B)
if q > A:
q = A
print((p + q))
| p02754 |
N, A, B = [int(x) for x in input().strip().split()]
p = N // (A + B) * A
q = N % (A + B)
if q > A:
q = A
print((p + q))
| """
Author: _YL_
"""
# b:blue, r:red
n, b, r = list(map(int, input().split()))
if b == 0:
print("0")
elif r == 0:
print(n)
else:
remainder = n % (b+r)
if remainder > b:
remainder = b
print((n//(b+r)*b+remainder)) | p02754 |
N, A, B = list(map(int, input().split()))
result = 0
current = "b"
while(N > 0):
if current == "b":
if N - A > 0:
result += A
N = N - A
else:
result += N
N = 0
current = "r"
else:
if N - B > 0:
N = N - B
else:
N = 0
current = "b"
print(result) | N, A, B = list(map(int, input().split()))
result = 0
x = N // (A+B)
result = A * x
N = N - ((A + B) * x)
if N < A:
result += N
else:
result += A
print(result) | p02754 |
N, A, B = list(map(int, input().split()))
lst = []
i = 0
while i < N:
for j in range(A):
lst.append("b")
i += 1
for k in range(B):
lst.append("r")
i += 1
# print("lst:", lst)
lst = lst[:N]
# print("lst:", lst)
print((lst.count('b'))) | # coding: utf-8
N, A, B = list(map(int, input().split()))
# print("N:", N, "A:", A, "B:", B)
if A == 0:
print((0))
elif B == 0 or N <= A:
print(N)
else:
num = int(N / (A + B)) * A + min(A, N % (A + B))
print(num)
| p02754 |
n,a,b = list(map(int,input().split()))
x = n // (a+b)
y = n % (a+b)
if y <= a:
print(((x*a) + y))
else:
print(((x*a) + a))
|
n,a,b = list(map(int,input().split()))
num = 0
num = n // (a+b)
if n % (a+b) <= a:
print(((num*a)+ (n % (a+b))))
else:
print(((num*a)+a))
| p02754 |
n,a,b=list(map(int,input().split()))
count=0
while n>0:
for i in range(a):
count+=1
n-=1
if n==0:
break
for i in range(b):
n-=1
if n==0:
break
if a==0:
print((0))
else:
print(count) | n,a,b=list(map(int,input().split()))
ab=a+b
num=n//ab
n-=ab*num
if n>=a:
ans=a
else:
ans=n
print((ans+num*a)) | p02754 |
a,b,c=list(map(int,input().split()))
n = a // (b+c)
m = a - (b+c)*n
res = n*b
for i in range(m):
if i < b:
res += 1
print(res) | a,b,c=list(map(int,input().split()))
n = a // (b+c)
m = a - (b+c)*n
res = n*b
if m < b:
res += m
else:
res += b
print(res) | p02754 |
N, A ,B =list(map(int,input().split()))
blue =0
while N >0:
blue += min(A,N)
N -= min(A,N)
N = max(N-B,0)
print(blue) | N, A ,B =list(map(int,input().split()))
print((N//(A+B)*A+min(N%(A+B),A)))
| p02754 |
N, A, B = list(map(int, input().split()))
ans = 0
while N > 0:
red = min(N, A)
ans += red
N -= red
blue = min(N, B)
N -= blue
print(ans)
| N, A, B = list(map(int, input().split()))
rep = N//(A+B)
ans = A*rep
diff = N - (A+B)*rep
ans += min(diff, A)
print(ans)
| p02754 |
#Input
N,A,B= list(map(int, input().split()))
#Process
cnt = 0
Ans = 0
flag_AB = True
while cnt < N:
if(flag_AB):
flag_AB = False
if(cnt + A < N):
Ans = Ans + A
else:
Ans = Ans + A - (cnt + A - N)
cnt = cnt + A
else:
flag_AB = True
cnt = cnt + B
#Output
print(Ans) | #Input
N,A,B= list(map(int, input().split()))
#Process
nokori = 0
na = int(N / (A + B))
if((A+B)*na + A > N):
nokori = N % (A + B)
else:
nokori = A
Ans = A * na + nokori
#Output
print(Ans) | p02754 |
n,a,b=list(map(int,input().split()))
k=[]
ans=0
count=(n//(a+b))
bb=[]
aa=[]
for j in range(a):
k.append('b')
for t in range(b):
k.append('r')
kk=k
for i in range(count):
for y in range(len(k)):
kk.append(k[y])
print((kk[:n].count('b'))) | n,a,b=list(map(int,input().split()))
t=n//(a+b)
j=n%(a+b)
ans=0
q=t*a
if(j<=a):
p=j
else:
p=a
ans=p+q
print(ans) | p02754 |
n,a,b=list(map(int,input().split()))
c=n//(a+b)
d=n%(a+b)
ans=c*a+min(d,a)
print(ans) | n,a,b=list(map(int,input().split()))
c=a+b
ans=n//c*a
ans+=min(a,n%c)
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
l = []
while len(l) <= n:
for _ in range(a):
l.append("b")
for _ in range(b):
l.append("r")
print((l[:n].count("b")))
| n, a, b = list(map(int, input().split()))
l = a + b
set_cnt = n // l
rest = n % l
if rest >= a:
ans = set_cnt * a + a
else:
ans = set_cnt * a + rest
print(ans) | p02754 |
# A = [list(map(int, input().split())) for _ in range(3)]
# n = int(input())
# B = [int(input()) for _ in range(n)]
# X = list(map(int, input().split()))
n, a, b = list(map(int, input().split()))
total = a+b
diff = n-((n//total)*total)
omake = n//total*a
if a <= diff:
print((a+omake))
else:
print((diff+omake))
| # A = [list(map(int, input().split())) for _ in range(3)]
# n = int(input())
# B = [int(input()) for _ in range(n)]
# X = list(map(int, input().split()))
n, a, b = list(map(int, input().split()))
total = a+b
diff = n % total
blue_in = n//total*a
if a <= diff:
print((a+blue_in))
else:
print((diff+blue_in))
| p02754 |
a,b,c=list(map(int,input().split()))
d=0
e=0
ok=False
total=int(a/(b+c))
sa=a-(b+c)*total
if total==0:
if a>=b:
print(b)
else:
print(a)
else:
if sa>=b:
print((b+b*total))
else:
print((sa+b*total)) | n,a,b=list(map(int,input().split()))
print(((n//(a+b))*a+max(0,min(a,(n-((n//(a+b))*(a+b))))))) | p02754 |
n, a, b = list(map(int, input().split()))
total = 0
out = 0
if a == 0:
pass
else:
while True:
total += a
out += a
if total >= n:
out -= (total - n)
break
total += b
if total >= n:
break
print(out) | n, a, b = list(map(int, input().split()))
q = n // (a + b)
mod = n % (a + b)
if mod > a:
remain = a
else:
remain = mod
print((q * a + remain)) | p02754 |
n,a,b = list(map(int,input().split()))
for i in range(10**9):
if i*(a+b)==n:
print((a*i))
exit()
elif i*(a+b)>n:
t = n-(i-1)*(a+b)
if t>a:
t = a
print(((i-1)*a+t))
exit() | n,a,b = list(map(int,input().split()))
ans = n // (a+b) * a
rem = n % (a+b)
ans += min(rem,a)
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
ans = []
def add_ball(a, b):
ball_list = []
for i in range(a):
ball_list.append('b')
if len(ball_list) == n:
return ball_list
for j in range(b):
ball_list.append('r')
if len(ball_list) == n:
return ball_list
return ball_list
for i in range((n // (a + b)) + 1):
ball_list = add_ball(a, b)
ans += ball_list
print((ans[:n].count('b'))) | n, a, b = list(map(int, input().split()))
ans = n // (a + b) * a
rem = n % (a + b)
ans += min(a, rem) # ansとremを比較することでnの位置よって処理を変えられる
print(ans)
| p02754 |
n, a, b = list(map(int, input().split()))
ans = 0
while True:
if n >= a:
n -= a
ans += a
else:
ans += n
break
if n >= b:
n -= b
else:
break
print(ans)
| n, a, b = list(map(int, input().split()))
ans = n//(a+b)*a
amari = n-(a+b)*(n//(a+b))
ans += min(amari, a)
print(ans)
| p02754 |
N, A, B = list(map(int, input().split()))
b_count = 0
n_count = 0
while n_count < N:
if n_count + A < N:
b_count += A
else:
b_count += N - n_count
break
n_count += A + B
print(b_count) | N, A, B = list(map(int, input().split()))
division = N // (A + B)
count = division * A
count += N - division * (A + B) if A > N - division * (A + B) else A
print(count) | p02754 |
n, a, b = list(map(int, input().split()))
al = a
bl = b
cnt = 0
for i in range(n):
if al != 0:
cnt += 1
al -= 1
elif bl != 0:
bl -= 1
if al == 0 and bl == 0:
bl = b
al = a
print(cnt) | n, a, b = list(map(int, input().split()))
ans = a * (n // (a + b))
if a < n % (a + b):
ans += a
else:
ans += n % (a + b)
print(ans) | p02754 |
N, A, B=list(map(int, input().split(" ")))
sum=0
flag=False
b=0
while True:
sum=sum+A
b=b+A
if sum>N:
flag=True
break
sum=sum+B
if sum>N:
break
if flag:
print((b-(sum-N)))
else:
print(b) | N, A, B=list(map(int, input().split(" ")))
result=A*(N//(A+B))+min(N%(A+B), A)
print(result) | p02754 |
N,A,B=list(map(int,input().split()))
x=[]
for i in range(1,N+A+B):
for j in range(A):
x.append("a")
for k in range(B):
x.append("b")
x=x[:N]
print((x.count("a"))) | N,A,B=list(map(int,input().split()))
num=N//(A+B)
res=N-num*(A+B)
count=0
if res<=A:
count=num*A+res
else:
count=num*A+A
print(count)
| p02754 |
n,a,b=list(map(int,input().split()))
m=n//(a+b)
n-=m*(a+b)
print((m*a+min(a,n))) | n,a,b=list(map(int,input().split()))
ans=a*(n//(a+b))
ans+=min(a,n%(a+b))
print(ans)
| p02754 |
N,A,B = list(map(int, input().split()))
cnt=0
cnt_blue=0
while cnt+A+B<N:
cnt+=A+B
cnt_blue+=A
print((cnt_blue+min(A,N-cnt))) | N,A,B = list(map(int, input().split()))
cnt_blue=A*(N//(A+B))
cnt_all=(A+B)*(N//(A+B))
print((cnt_blue+min(A,N-cnt_all))) | p02754 |
N,A,B=[int(x) for x in input().rstrip().split()]
ans=N//(A+B)
amari=N%(A+B)
if A<=amari:
amari=A
ans1=ans*A+amari
print(ans1) | N,A,B=[int(x) for x in input().rstrip().split()]
num=N//(A+B)
amari=N%(A+B)
tasu=0
if amari<=A:
tasu=amari
else:
tasu=A
print((num*A+tasu))
| p02754 |
n,a,b = list(map(int,input().split()))
ans = []
while(len(ans) < n):
for i in range(a):
if(len(ans) >= n):
break
ans.append(1)
for i in range(b):
ans.append(0)
print((sum(ans))) | n,a,b = list(map(int,input().split()))
print((a*(n//(a+b)) + min(n%(a+b),a))) | p02754 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.