input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def main():
import sys
#input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations
#from itertools import accumulate, product, permutations
from math import floor, ceil
#mod = 1000000007
n,m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for _ in range(m)]
res = []
visited = [0]*n
def dfs(node):
visited[node-1]=1
if sum(visited)==n:
res.append(1)
return
for x,y in edge:
if x == node:
if not visited[y-1]:
dfs(y)
visited[y-1] = 0
if y == node:
if not visited[x-1]:
dfs(x)
visited[x-1] = 0
for a,b in edge:
if a==1:
dfs(a)
print((len(res)))
exit()
if __name__ == '__main__':
main() | '''
頂点1から全頂点通る一筆書きが何個あるか
頂点数(N)は最大で8なので道順を全列挙して調べてもいける
'''
def main():
import sys
#input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations
#from itertools import accumulate, product, permutations
from math import floor, ceil
#mod = 1000000007
N,M = list(map(int, input().split()))
g = [[] for _ in range(N)]
for _ in range(M):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
res = []
visited = [0]*N
def dfs(node):
visited[node]=1
if sum(visited)==N:
res.append(1)
return
for n_node in g[node]:
if not visited[n_node]:
dfs(n_node)
visited[n_node] = 0
dfs(0)
print((len(res)))
# My
# n,m = map(int, input().split())
# edge = [list(map(int, input().split())) for _ in range(m)]
# res = []
# visited = [0]*n
# def dfs(node):
# visited[node-1]=1
# if sum(visited)==n:
# res.append(1)
# return
# for x,y in edge:
# if x == node:
# if not visited[y-1]:
# dfs(y)
# visited[y-1] = 0
# if y == node:
# if not visited[x-1]:
# dfs(x)
# visited[x-1] = 0
# for a,b in edge:
# if a==1:
# dfs(a)
# print(len(res))
# exit()
# if b==1:
# dfs(b)
# print(len(res))
# exit()
if __name__ == '__main__':
main() | p03805 |
'''
頂点1から全頂点通る一筆書きが何個あるか
頂点数(N)は最大で8なので道順を全列挙して調べてもいける
'''
def main():
import sys
#input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations
#from itertools import accumulate, product, permutations
from math import floor, ceil
#mod = 1000000007
N,M = list(map(int, input().split()))
g = [[] for _ in range(N)]
for _ in range(M):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
res = []
visited = [0]*N
def dfs(node):
visited[node]=1
if sum(visited)==N:
res.append(1)
return
for n_node in g[node]:
if not visited[n_node]:
dfs(n_node)
visited[n_node] = 0
dfs(0)
print((len(res)))
# My
# n,m = map(int, input().split())
# edge = [list(map(int, input().split())) for _ in range(m)]
# res = []
# visited = [0]*n
# def dfs(node):
# visited[node-1]=1
# if sum(visited)==n:
# res.append(1)
# return
# for x,y in edge:
# if x == node:
# if not visited[y-1]:
# dfs(y)
# visited[y-1] = 0
# if y == node:
# if not visited[x-1]:
# dfs(x)
# visited[x-1] = 0
# for a,b in edge:
# if a==1:
# dfs(a)
# print(len(res))
# exit()
# if b==1:
# dfs(b)
# print(len(res))
# exit()
if __name__ == '__main__':
main() | res = 0
def main():
import sys
#input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations
#from itertools import accumulate, product, permutations
from math import floor, ceil
#mod = 1000000007
N,M = list(map(int, input().split()))
g = [[] for _ in range(N)]
for _ in range(M):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
visited = [0]*N
def dfs(node):
global res
visited[node]=1
if all(visited):
res += 1
return
for n_node in g[node]:
if not visited[n_node]:
dfs(n_node)
visited[n_node] = 0
dfs(0)
print(res)
if __name__ == '__main__':
main()
| p03805 |
import sys
input=sys.stdin.readline
#グラフの連結成分を調べる
def Graph(ab):
G=[[] for i in range(n)]
for a,b in ab:
G[a-1].append(b)
G[b-1].append(a)
return G
from collections import deque
def dfs(G,v,p,n):
q=deque()
q.append((v,p,1,0))
log=[0]*n
log[v-1]=1
ans=0
while q:
V,P,cnt,S=q.pop()
if S==0:
#下に遷移していくときの処理
q.append((V,P,cnt,1))
for new_v in G[V-1]:
if new_v==P:continue
if log[new_v-1]:continue
log[V-1]=1
q.append((new_v,V,cnt+1,0))
if cnt==n-1:ans+=1
else:
log[P-1]=0
return ans
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(m)]
G=Graph(ab)
#print(G)
ans=dfs(G,1,-1,n)
print(ans) | import sys
input=sys.stdin.readline
#グラフの連結成分を調べる
def Graph(ab):
G=[[] for i in range(n)]
for a,b in ab:
G[a-1].append(b)
G[b-1].append(a)
return G
from collections import deque
def dfs(G,v,p,n):
q=deque()
q.append((v,p,1,0))
log=[0]*n
log[v-1]=1
ans=0
while q:
V,P,cnt,S=q.pop()
if S==0:
#下に遷移していくときの処理
q.append((V,P,cnt,1))
for new_v in G[V-1]:
if new_v==P:continue
if log[new_v-1]:continue
log[V-1]=1
#print(V, new_v, cnt, q, log)
if cnt==n-1:
ans+=1
continue
q.append((new_v,V,cnt+1,0))
else:
log[V-1]=0
return ans
n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(m)]
G=Graph(ab)
#print(G)
ans=dfs(G,1,-1,n)
print(ans) | p03805 |
from itertools import permutations
N,M = list(map(int,input().split()))
Matrix = [[False for i in range(N)] for j in range(N)]
for i in range(M) :
a,b = list(map(int,input().split()))
a -= 1
b -= 1
Matrix[a][b] = True
Matrix[b][a] = True
for i in range(N) :
Matrix[i][i] = True
arange = list(range(2,N+1))
ans = 0
for pm in permutations(arange) :
pm = [1] + list(pm)
for row,col in zip(pm,pm[1:]) :
row -= 1
col -= 1
if not Matrix[row][col] :
break
else :
ans += 1
print(ans)
| from itertools import permutations
N,M = list(map(int,input().split()))
Matrix = [[False for x in range(N)] for y in range(N)]
for i in range(N) :
Matrix[i][i] = True
for i in range(M) :
a,b = list(map(int,input().split()))
a -= 1
b -= 1
Matrix[a][b] = True
Matrix[b][a] = True
arange = permutations(list(range(1,N)))
ans = 0
for i in arange :
pm = [0] + list(i)
for a,b in zip(pm, pm[1:]) :
if not Matrix[a][b] :
break
else :
ans += 1
print(ans)
| p03805 |
from itertools import permutations
N,M = list(map(int,input().split()))
L = [[] for i in range(N)]
for i in range(M) :
a,b = list(map(int,input().split()))
a -= 1
b -= 1
L[a].append(b)
L[b].append(a)
P = permutations([0] + [i for i in range(1,N)])
ans = 0
for perm in P :
visited = [0 for i in range(N)]
visited[0] = 1
for i in range(N-1) :
if perm[i+1] not in L[perm[i]] :
break
if visited[perm[i+1]] :
break
visited[perm[i+1]] = 1
if sum(visited) == N :
ans += 1
print(ans)
| from itertools import permutations
N,M = list(map(int,input().split()))
L = [[False for j in range(N)] for i in range(N)]
for i in range(M) :
a,b = list(map(int,input().split()))
a -= 1
b -= 1
L[a][b] = True
L[b][a] = True
P = list(permutations(list(range(1,N))))
ans = 0
for perm in P :
perm = list(perm)
for s,g in zip([0] + perm, perm) :
if not L[s][g] :
break
else :
ans += 1
print(ans)
| p03805 |
from itertools import permutations
from math import factorial
n, m = list(map(int, input().split(' ')))
edge = []
for i in range(m):
ai, bi = list(map(int, input().split(' ')))
edge.append([ai,bi])
x = [i for i in range(1,n+1)]
ls = list(permutations(x))
ans = 0
for l in range(factorial(n-1)):
cnt = 0
for i in range(n-1):
for j in range(m):
if (ls[l][i] in edge[j]) and (ls[l][i+1] in edge[j]):
cnt += 1
if cnt == n-1:
ans += 1
print(ans)
| from itertools import permutations
from math import factorial
n, m = list(map(int, input().split(' ')))
edge = []
for i in range(m):
ai, bi = list(map(int, input().split(' ')))
edge.append([ai, bi])
l = [i for i in range(1, n+1)]
ls = list(permutations(l))
ans = 0
for i in range(factorial(n-1)):
y = 0
for j in range(n-1):
for k in edge:
if (ls[i][j+1] in k) and (ls[i][j] in k):
y += 1
if y == n-1:
ans += 1
print(ans) | p03805 |
import itertools
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
P = N-1
count = 0
for path in itertools.permutations(ab, P):
flag = True
prev = 1
memo = [0]*N
for i in range(P):
memo[prev-1] += 1
if flag == True:
if path[i][0] == prev:
prev = path[i][1]
elif path[i][1] == prev:
prev = path[i][0]
else:
flag = False
continue
if 0 < memo[prev-1]:
flag = False
continue
if i == P-1:
count += 1
print(count)
| import itertools
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
count = 0
for path in itertools.permutations([i for i in range(2, N+1)], N-1):
flag = True
if [1, path[0]] in ab or [path[0], 1] in ab:
pass
else:
flag = False
continue
for i in range(1, N):
if flag:
if i == N-1:
count += 1
continue
if [path[i-1], path[i]] in ab or [path[i], path[i-1]] in ab:
continue
else:
flag = False
print(count)
| p03805 |
# https://atcoder.jp/contests/abc054/tasks/abc054_c
import copy
import sys
input = sys.stdin.readline
# 頂点, 辺の数
N, M = list(map(int, input().split()))
# グラフのリスト
# 各頂点からどこの頂点に向かう辺があるかどうかという情報
Graph_list = [[] for i in range(N)]
# 入力
for i in range(M):
a, b = list(map(int, input().split()))
a += -1
b += -1
# 無向グラフなのでa, b両方
Graph_list[a].append(b)
Graph_list[b].append(a)
ans_count = 0 # 正解の経路の数
checked_list = [] # すでに通ったことのあるリスト
throwgh_point_list = [-1 for i in range(N)] # 経路のリスト（全探索用）
def dfs(i, current, throwgh_point_list):
# 頂点をN個通ったら終了処理
if i >= N-1:
# 最後の点を追加
throwgh_point_list[i] = current
global checked_list
# すでに考慮したことのあるリストの場合
if throwgh_point_list in checked_list:
return
checked_list.append(copy.copy(throwgh_point_list))
# 全ての点に到達している場合
# 順不同で比較
if set(throwgh_point_list) == set(list(range(N))):
global ans_count
ans_count += 1
return
for j in Graph_list[current]:
# 現在地を書き込む
throwgh_point_list[i] = current
# 次の点に移動する
dfs(i + 1, j, throwgh_point_list)
dfs(0, 0, throwgh_point_list)
print(ans_count) | # https://atcoder.jp/contests/abc054/tasks/abc054_c
import copy
import sys
input = sys.stdin.readline
# 頂点, 辺の数
N, M = list(map(int, input().split()))
# グラフのリスト
# 各頂点からどこの頂点に向かう辺があるかどうかという情報
Graph_list = [[] for i in range(N)]
# 入力
for i in range(M):
a, b = list(map(int, input().split()))
a += -1
b += -1
# 無向グラフなのでa, b両方
Graph_list[a].append(b)
Graph_list[b].append(a)
ans_count = 0 # 正解の経路の数
visited = [False] * N
visited[0] = True
def dfs(i, current, visited):
# 頂点をN個通ったら終了処理
if i >= N-1:
# 全ての点に到達している場合
if all(visited):
global ans_count
ans_count += 1
return
return
for j in Graph_list[current]:
if visited[j] == False:
# 現在地を書き込む
visited[j] = True
# 次の点に移動する
dfs(i + 1, j, visited)
visited[j] = False
dfs(0, 0, visited)
print(ans_count) | p03805 |
from itertools import permutations
N, M, *ab = list(map(int, open(0).read().split()))
g = [[0] * N for _ in range(N)]
for a, b in zip(*[iter(ab)] * 2):
g[a - 1][b - 1] = 1
g[b - 1][a - 1] = 1
ans = 0
for path in permutations(list(range(1, N))):
path = [0] + list(path)
if all(g[v][nv] for v, nv in zip(path, path[1:])):
ans += 1
print(ans)
| def dfs(v):
if sum(visited) == N:
return 1
res = 0
for nv in g[v]:
if visited[nv]:
continue
visited[nv] = 1
res += dfs(nv)
visited[nv] = 0
return res
N, M, *ab = list(map(int, open(0).read().split()))
g = [[] for _ in range(N)]
for a, b in zip(*[iter(ab)] * 2):
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
visited = [0] * N
visited[0] = 1
print((dfs(0)))
| p03805 |
from copy import deepcopy
cnt = 0
depth = 0
def main():
n, m = list(map(int, input().split()))
adj = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
adj[a].append(b)
adj[b].append(a)
def f(u, d):
global cnt, depth
cp = deepcopy(d)
cp[u] = depth
if cp.count(-1) == 0:
cnt += 1
else:
vs = adj[u]
depth += 1
for v in vs:
if cp[v] == -1:
f(v, cp)
depth -= 1
f(0, [-1] * n)
print(cnt)
if __name__ == "__main__":
main()
| class Graph:
def __init__(self, n, adj):
self.adj = adj
self.cnt = 0
self.depth = 0
self.ds = [-1] * n
def solve(self, u):
self.ds[u] = self.depth
if self.ds.count(-1) == 0:
self.cnt += 1
return
self.depth += 1
for v in self.adj[u]:
if self.ds[v] == -1:
self.solve(v)
self.ds[v] = -1
self.depth -= 1
def main():
n, m = list(map(int, input().split()))
adj = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
adj[a].append(b)
adj[b].append(a)
graph = Graph(n, adj)
graph.solve(0)
print((graph.cnt))
if __name__ == "__main__":
main()
| p03805 |
class Graph:
def __init__(self):
n, m = list(map(int, input().split()))
self.adj = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
self.adj[a].append(b)
self.adj[b].append(a)
self.cnt = 0
self.depth = 0
self.ds = [-1] * n
def solve(self, u):
self.ds[u] = self.depth
if self.ds.count(-1) == 0:
self.cnt += 1
return
self.depth += 1
for v in self.adj[u]:
if self.ds[v] == -1:
self.solve(v)
self.ds[v] = -1
self.depth -= 1
def main():
graph = Graph()
graph.solve(0)
print((graph.cnt))
if __name__ == "__main__":
main()
| from itertools import permutations
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
g = [[0] * n for _ in range(n)]
for a, b in ab:
a -= 1
b -= 1
g[a][b] = 1
g[b][a] = 1
ans = 0
for pat in permutations(list(range(1, n)), n - 1):
is_path = True
u = 0
for v in pat:
if g[u][v] == 0:
is_path = False
u = v
if is_path:
ans += 1
print(ans)
| p03805 |
def DFS(s):
global ans,color
color[s]="gray"
if "white" not in color:
ans +=1
for i in M[s]:
if color[i]=="white":
DFS(i)
color[s]="white"
n,m=list(map(int,input().split()))
M=[[] for _ in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
M[a-1].append(b-1)
M[b-1].append(a-1)
color=["white" for _ in range(n)]
ans=0
DFS(0)
print(ans) | def DFS(s):
global ans,color
color[s]="black"
if "white" not in color:
ans +=1
for i in M[s]:
if color[i]=="white":
DFS(i)
color[s]="white"
n,m=list(map(int,input().split()))
M=[[] for _ in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
M[a-1].append(b-1)
M[b-1].append(a-1)
color=["white" for _ in range(n)]
ans=0
DFS(0)
print(ans) | p03805 |
def DFS(s):
global ans,color
color[s]="black"
if "white" not in color:
ans +=1
for i in M[s]:
if color[i]=="white":
DFS(i)
color[s]="white"
n,m=list(map(int,input().split()))
M=[[] for _ in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
M[a-1].append(b-1)
M[b-1].append(a-1)
color=["white" for _ in range(n)]
ans=0
DFS(0)
print(ans) | def DFS(num):
global ans,color
color[num]="black"
if "white" not in color:
ans +=1
for i in M[num]:
if color[i]=="white":
DFS(i)
color[num]="white"
n,m=list(map(int,input().split()))
AB=[list(map(int,input().split())) for _ in range(m)]
M=[[] for _ in range(n)]
color=["white" for _ in range(n)]
for a,b in AB:
M[a-1].append(b-1)
M[b-1].append(a-1)
ans=0
DFS(0)
print(ans) | p03805 |
n, m = list(map(int, input().split()))
g = [[]for _ in range(n + 1)]
for _ in range(m):
a, b = list(map(int, input().split()))
g[a].append(b)
g[b].append(a)
ret = 0
def walk(node, visited):
global ret
tmp = visited + [node]
if len(tmp) == n:
ret += 1
for nd in g[node]:
if nd not in tmp:
walk(nd, tmp)
walk(1, [])
print(ret)
| N, M = list(map(int, input().split()))
g = [[] for _ in range(N + 1)]
for _ in range(M):
a, b = list(map(int, input().split()))
g[a].append(b)
g[b].append(a)
ans = 0
def walk(cur, visited):
global ans
tmp = visited + [cur]
if len(tmp) == N:
ans += 1
for nex in g[cur]:
if nex not in tmp:
walk(nex, tmp)
walk(1, [])
print(ans)
| p03805 |
N, M = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
to[a].append(b)
to[b].append(a)
res = 0
def dfs(v, seen):
global res
if seen == [1] * N:
res += 1
return
for nv in to[v]:
if not seen[nv]:
seen[nv] = 1
dfs(nv, seen)
seen[nv] = 0
def main():
seen = [0] * N
seen[0] = 1
dfs(0, seen)
print(res)
if __name__ == "__main__":
main()
| N, M = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
to[a].append(b)
to[b].append(a)
def dfs(v, seen):
if seen == [1] * N:
return 1
res = 0
for nv in to[v]:
if not seen[nv]:
seen[nv] = 1
res += dfs(nv, seen)
seen[nv] = 0
return res
def main():
seen = [0] * N
seen[0] = 1
print((dfs(0, seen)))
if __name__ == "__main__":
main()
| p03805 |
# coding: utf-8
count=0
def check(now,v,n):
global count
v[now]=1
if sum(v)==n:
count+=1
else:
for i in range(8):
if v[i]==0 and g[now][i]==1:
check(i,v[:],n)
n,m=list(map(int,input().split()))
g=[[0 for i in range(8)]for i in range(8)]
for i in range(m):
a,b=list(map(int,input().split()))
g[a-1][b-1]=1
g[b-1][a-1]=1
check(0,[0,0,0,0,0,0,0,0][:],n)
print(count) | # coding: utf-8
count=0
def check(now,v,n):
global count
v[now]=1
if sum(v)==n:
count+=1
else:
for i in range(n):
if v[i]==0 and g[now][i]==1:
check(i,v[:],n)
n,m=list(map(int,input().split()))
g=[[0 for i in range(n)]for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
g[a-1][b-1]=1
g[b-1][a-1]=1
check(0,[0 for i in range(n)],n)
print(count) | p03805 |
import itertools
N, M = list(map(int, input().split()))
ab = [0] * M
for i in range(M):
ab[i] = list(map(int, input().split()))
perms = itertools.permutations(list(range(1, N+1)))
ans = 0
for perm in perms:
if perm[0] != 1:
continue
is_goal = True
for i in range(N-1):
a = perm[i]
b = perm[i+1]
if not a < b:
a, b = b, a
if not [a, b] in ab:
is_goal = False
if is_goal:
ans += 1
print(ans)
| # https://img.atcoder.jp/abc054/editorial.pdf
N, M = list(map(int, input().split()))
graph = [[False for _ in range(N)] for i in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
graph[a-1][b-1] = graph[b-1][a-1] = True
def dfs(v, visited):
all_visited = True
for i in range(N):
if not visited[i]:
all_visited = False
if all_visited:
return 1
ret = 0
for i in range(N):
if not graph[v][i]: continue
if visited[i]: continue
visited[i] = True
ret += dfs(i, visited)
visited[i] = False
return ret
visited = [False] * N
visited[0] = True
ans = dfs(0, visited)
print(ans)
| p03805 |
import sys
readline = sys.stdin.readline
N,M = list(map(int,readline().split()))
G = [[] for i in range(N)]
for i in range(M):
a,b = list(map(int,readline().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
ans = 0
stack = []
stack.append([0,set()])
while stack:
v,visited = stack.pop()
if v in visited:
continue
visited2 = visited.copy()
visited2.add(v)
if len(visited2) == N:
ans += 1
continue
for child in G[v]:
stack.append([child,visited2])
print(ans) | import sys
readline = sys.stdin.readline
N,M = list(map(int,readline().split()))
G = [[] for i in range(N)]
for i in range(M):
a,b = list(map(int,readline().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
stack = []
stack.append([0, set()])
ans = 0
while stack:
v, visited = stack.pop()
visited.add(v)
if len(visited) == N:
ans += 1
continue
for child in G[v]:
if child in visited:
continue
visited_c = visited.copy()
stack.append([child, visited_c])
print(ans) | p03805 |
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())
nmax=8
graph=[[False for __ in range(nmax)]for _ in range(nmax)]
def dfs(v,n,visited):
visited[v]=True
all_visited=True
for i in range(n):
if visited[i]==False:
all_visited=False
if all_visited:
return 1
ret=0
for i in range(n):
if graph[v][i]==False:
continue
if visited[i]:
continue
visited[i]=True
ret+=dfs(i,n,visited)
visited[i]=False
return ret
def main():
n,m=LI()
for _ in range(m):
a,b=LI()
graph[a-1][b-1]=True
graph[b-1][a-1]=True
visited=[False for _ in range(n)]
visited[0]=True
return dfs(0,n,visited)
# main()
print((main()))
| # https://atcoder.jp/contests/abc054/tasks/abc054_c
import math,itertools,fractions,heapq,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())
nmax=8
graph=[[False]*nmax for _ in range(nmax)]
def dfs(n,v,visited):
all_visited=True
for i in range(n):
if visited[i]==False:
all_visited=False
if all_visited:
return 1
ret=0
for i in range(n):
if visited[i]:
continue
if graph[i][v]==False:
continue
visited[i]=True
ret+=dfs(n,i,visited)
visited[i]=False
return ret
def main():
n,m=LI()
for _ in range(m):
a,b=LI()
a-=1
b-=1
graph[a][b]=True
graph[b][a]=True
visited=[False]*n
visited[0]=True
return dfs(n,0,visited)
# main()
print((main()))
| p03805 |
# https://atcoder.jp/contests/abc054/tasks/abc054_c
import math,itertools,fractions,heapq,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())
nmax=8
graph=[[False]*nmax for _ in range(nmax)]
def dfs(n,v,visited):
all_visited=True
for i in range(n):
if visited[i]==False:
all_visited=False
if all_visited:
return 1
ret=0
for i in range(n):
if visited[i]:
continue
if graph[i][v]==False:
continue
visited[i]=True
ret+=dfs(n,i,visited)
visited[i]=False
return ret
def main():
n,m=LI()
for _ in range(m):
a,b=LI()
a-=1
b-=1
graph[a][b]=True
graph[b][a]=True
visited=[False]*n
visited[0]=True
return dfs(n,0,visited)
# 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())
N,M=LI()
graph=[[False]*8 for _ in range(8)]
for _ in range(M):
a,b=LI()
a-=1
b-=1
graph[a][b]=True
graph[b][a]=True
def dfs(v,visited):
all_visited=True
for i in range(N):
if not visited[i]:
all_visited=False
if all_visited:
return 1
ret=0
for i in range(N):
if not graph[v][i]:
continue
if visited[i]:
continue
visited[i]=True
ret+=dfs(i,visited)
visited[i]=False
return ret
visited=[False]*N
visited[0]=True
print((dfs(0,visited)))
| p03805 |
import itertools
N, M = list(map(int, input().split()))
graph = [[0] * N for i in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
graph[a-1][b-1] = 1
graph[b-1][a-1] = 1
p = list(itertools.permutations(list(range(N))))
Sum = 0
for i in range(len(p)):
if p[i][0] != 0:
break
for j in range(N - 1):
if graph[p[i][j]][p[i][j + 1]] != 1:
break
elif j == N - 2:
Sum += 1
print(Sum) | N, M = list(map(int, input().split()))
g = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
visited = [False for _ in range(N)]
def dfs(v, visited):
if all(visited):
return 1
total = 0
for cv in g[v]:
if not visited[cv]:
visited[cv] = True
total += dfs(cv, visited)
visited[cv] = False
return total
visited[0] = True
ret = dfs(0, visited)
print(ret) | p03805 |
import itertools
N, M = list(map(int, input().split()))
E = set([tuple(sorted(map(int, input().split()))) for x in range(M)])
cnt = 0
for i in itertools.permutations(list(range(2,N+1)), N-1):
l = [1]+list(i)
if sum(1 for x in range(N-1) if tuple(sorted(l[x:x+2])) in E) == N-1:
cnt += 1
print(cnt) | import itertools
N, M = list(map(int, input().split()))
D = {tuple(sorted(map(int, input().split()))) for x in range(M)}
cnt = 0
for i in itertools.permutations(list(range(2, N+1)), N-1):
l = [1]+list(i)
cnt += sum(1 for x in zip(l,l[1:]) if tuple(sorted(x)) in D) == N-1
print(cnt) | p03805 |
# ABC054 C One-stroke Path
N,M = list(map(int, input().split()))
G = [[] for _ in range(N)]
reached = [False]*N
for _ in range(M):
a,b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
cnt = 0
def DFS(x):
global cnt
global reached
reached[x] = True
if all(reached):
cnt += 1
reached[x] = False
return
for i in G[x]:
if reached[i]:
continue
else:
DFS(i)
reached[x] = False
DFS(0)
print(cnt) | #ABC054 C - One-stroke Path
# v：現在の頂点 seen:訪問済みの頂点
def dfs(v,seen):
if all(seen):
return 1
res = 0
# 頂点ｖに隣接しているnvを探索していく
for nv in G[v]:
if seen[nv]:
continue
seen[nv]=True
res += dfs(nv,seen)
# 次の隣接頂点nvを探索した時の探索経路で、
# 今回探索した隣接頂点nv通る可能性があるので
# 元に戻しておく
seen[nv]=False
return res
n,m = list(map(int, input().split()))
G = [[] for _ in range(n)]
seen = [False]*n
res = 0
for i in range(m):
a,b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
# 頂点1を訪問済みとして探索を開始する
seen[0]=True
print((dfs(0,seen)))
| p03805 |
n,m=list(map(int,input().split()))
G=[[0]*n for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
G[a-1][b-1]=G[b-1][a-1]=1
from itertools import permutations
ans=0
p=list(permutations([x for x in range(1,n)]))
for pp in p:
ok=True
t=[0]+list(pp)
for i in range(1,n):
if G[t[i-1]][t[i]]==0:
ok=False
if ok:ans+=1
print(ans)
| def dfs(v,visited):
if all(visited):
return 1
res=0
for nv in G[v]:
if visited[nv]:
continue
visited[nv]=1
res+=dfs(nv,visited)
visited[nv]=0
return res
n,m=list(map(int, input().split()))
G=[[] for _ in range(n)]
visited=[0]*n
res=0
for i in range(m):
a,b=list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
visited[0]=1
print((dfs(0,visited))) | p03805 |
import itertools
n,m= list(map(int, input().split()))
a= [list(map(int, input().split())) for i in range(m)]
# 経路全探索
ans=0
for v in itertools.combinations(a, n-1):
b=[[] for i in range(n)]
for x,y in v:
b[x - 1].append(y - 1)
b[y - 1].append(x - 1)
import collections
from collections import deque
def tree(s):
INF = -10 ** 9
dis = [INF for i in range(n)]
dis[s] = 0
def bfs():
d = deque()
d.append(s)
while len(d):
x = d.popleft()
for i in range(len(b[x])):
y = b[x][i]
if dis[y] == INF:
d.append(y)
dis[y] = dis[x] + 1
return max(dis)
return bfs()
if tree(0)==n-1:
ans+=1
print(ans) | N, M = list(map(int, input().split()))
es = [[] for i in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
es[a-1].append(b-1)
es[b-1].append(a-1)
def dfs(v, used, cnt):
used[v] = 1
if all(used):
cnt.append(1)
for nv in es[v]:
if used[nv]:
continue
dfs(nv, used, cnt)
used[v] = 0
used = [0] * N
cnt = []
dfs(0, used, cnt)
print((sum(cnt)))
| p03805 |
def multival(): return list(map(int,input().split()))
def data(N=1): return [list(map(int,input().split())) for _ in range(N)]
mod = 10**9 + 7
inf = float("inf")
N,M = multival()
nemat = [[0]*N for _ in range(N)]
ans = 0
for _ in range(M):
a,b = multival()
a -= 1; b-= 1
nemat[a][b] = 1
nemat[b][a] = 1
def dfs(now=0,visited=[False]*N):
visited[now] = True
if all(visited) is True:
global ans
ans += 1
for ne in range(N):
if nemat[now][ne] == 1 and visited[ne] is False:
dfs(ne,visited[:])
# visited[:]
# n方向に分かれて探索する際にそれぞれ別のvisitedを持たせる
# そうしなければ例えばsample1では 1->2->3 と進んで全てに訪問済みの印が付く
# 次に1->2と進もうとしても2は既にTrueに更新済みなので探索が終了してしまう
dfs()
print(ans) | N,M = list(map(int,input().split()))
ad = [[0]*N for _ in range(N)]
for _ in range(M):
a,b = list(map(int,input().split()))
a -= 1; b -= 1
ad[a][b] = 1
ad[b][a] = 1
ans = 0
def dfs(v=0,d=0,visited=[1]+[0]*(N-1)):
if d == N-1:
global ans
ans += 1
return
for nv, bit in enumerate(ad[v]):
if bit == 0: continue
if visited[nv] == 1: continue
visited[nv] = 1
dfs(nv,d+1)
visited[nv] = 0
dfs()
print(ans) | p03805 |
N,M = list(map(int, input().split()))
edge= [[] for i in range(N+1)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a].append(b)
edge[b].append(a)
result = []
import copy
def dfs(n,used,d):
if d == N-1:
result.append(1)
for e in edge[n]:
if used[e] == False:
usedf = copy.deepcopy(used)
usedf[e] = True
dfs(e,usedf,d+1)
used = [False]*(N+1)
used[1] = True
dfs(1,used,0)
print((len(result)))
| N,M = list(map(int, input().split()))
edge= [[] for i in range(N+1)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a].append(b)
edge[b].append(a)
import itertools
per = itertools.permutations([i for i in range(1,N+1)])
ans = 0
for item in per:
if item[0] != 1:
continue
f = True
for ind,num in enumerate(item):
if ind + 1<= N-1:
nnum = item[ind+1]
if nnum not in edge[num]:
f = False
if f:
ans += 1
print(ans)
| p03805 |
N, M = list(map(int, input().split()))
graph ={i+1:[] for i in range(N)}
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
def dfs(path, n, cnt):
if(len(path) == N):
return cnt+1
for j in graph[n]:
if(j in path):
continue
cnt = dfs(path+[j], j, cnt)
return cnt
print((dfs([1], 1, 0))) | N, M = list(map(int, input().split()))
dict = {i+1:[] for i in range(N)}
for _ in range(M):
a, b = list(map(int, input().split()))
dict[a].append(b)
dict[b].append(a)
def DFS(visited, sight, cnt):
if(len(visited) == N):
return cnt+1
for num in dict[sight]:
if num in visited:
continue
cnt = DFS(visited+[num], num, cnt)
return cnt
print((DFS([1], 1, 0))) | p03805 |
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [e] * (2 * self.size)
self.lz = [id] * (self.size)
def update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size:
self.lz[k] = self.composition(f, self.lz[k])
def push(self, k):
self.all_apply(2 * k, self.lz[k])
self.all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.d[self.size + i] = a
for i in range(1, self.size)[::-1]:
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.d[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = list(map(int, input().split()))
def op(x, y):
xv, xr = x >> 32, x % (1 << 32)
yv, yr = y >> 32, y % (1 << 32)
return ((xv + yv) % MOD << 32) + (xr + yr) % MOD
def mapping(p, x):
xv, xr = x >> 32, x % (1 << 32)
if p != INF:
return ((p * xr % MOD) << 32) + xr
else:
return x
def composition(p, q):
if p != INF:
return p
else:
return q
arr = [(pow(10, N - 1 - i, MOD) << 32) + pow(10, N - 1 - i, MOD) for i in range(N)]
e = 0
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(arr)
res = list()
for _ in range(Q):
l, r, d = list(map(int, input().split()))
lst.range_apply(l - 1, r, d)
v = lst.all_prod()
res.append(v >> 32)
print(('\n'.join(map(str, res)))) | class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [e] * (2 * self.size)
self.lz = [id] * (self.size)
def update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size:
self.lz[k] = self.composition(f, self.lz[k])
def push(self, k):
self.all_apply(2 * k, self.lz[k])
self.all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.d[self.size + i] = a
for i in range(1, self.size)[::-1]:
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.d[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = list(map(int, input().split()))
def op(x, y):
xv, xr = x >> 32, x % (1 << 32)
yv, yr = y >> 32, y % (1 << 32)
return ((xv + yv) % MOD << 32) + (xr + yr) % MOD
def mapping(p, x):
xv, xr = x >> 32, x % (1 << 32)
if p != INF:
return ((p * xr % MOD) << 32) + xr
else:
return x
def composition(p, q):
if p != INF:
return p
else:
return q
def build_exp(n, b):
res = [0] * (n + 1)
res[0] = 1
for i in range(n):
res[i + 1] = res[i] * b % MOD
return res
exp = build_exp(N - 1, 10)
arr = [(e << 32) + e for e in exp[::-1]]
e = 0
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(arr)
res = list()
for _ in range(Q):
l, r, d = list(map(int, input().split()))
lst.range_apply(l - 1, r, d)
v = lst.all_prod()
res.append(v >> 32)
print(('\n'.join(map(str, res)))) | p02538 |
import sys
sys.setrecursionlimit(10**7)
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,Q = MI()
mod = 998244353
power = [1] # power[i] = 10**i
for i in range(N):
power.append((power[-1]*10) % mod)
t = pow(9,mod-2,mod) # 9 の逆数
class LazySegTree(): # モノイドに対して適用可能、Nが2冪でなくても良い
def __init__(self,N,X_func,A_func,operate,X_unit,A_unit):
self.N = N
self.X_func = X_func
self.A_func = A_func
self.operate = operate
self.X_unit = X_unit
self.A_unit = A_unit
self.X = [self.X_unit]*(2*self.N)
self.A = [self.A_unit]*(2*self.N)
self.size = [0]*(2*self.N)
def build(self,init_value): # 初期値を[N,2N)に格納
for i in range(self.N):
self.X[self.N+i] = init_value[i]
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.X[i] = self.X_func(self.X[i << 1],self.X[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.X[i] = x
i >>= 1
while i:
self.X[i] = self.X_func(self.X[i << 1],self.X[i << 1 | 1])
i >>= 1
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.X[i],self.A[i],self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
i >>= 1
while i:
self.X[i] = self.X_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
i >>= 1
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.X[i] = self.operate(self.X[i],self.A[i],self.size[i])
self.A[i << 1] = self.A_func(self.A[i << 1],self.A[i])
self.A[i << 1 | 1] = self.A_func(self.A[i << 1 | 1], self.A[i])
self.A[i] = self.A_unit
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.X_unit
vR = self.X_unit
while L < R:
if L & 1:
vL = self.X_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.X_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.X_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.A[L] = self.A_func(self.A[L],x)
L += 1
if R & 1:
R -= 1
self.A[R] = self.A_func(self.A[R],x)
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
def X_func(x,y):
x1,x2 = x
y1,y2 = y
return ((x1*power[y2]+y1) % mod,x2+y2)
def A_func(a,b):
a1,a2 = a
b1,b2 = b
return ((a1*b1) % mod,(a2*b1+b2) % mod)
def operate(x,a,r): # 右作用
x1,x2 = x
a1,a2 = a
return (a1*x1+(a2*(power[x2]-1)*t) % mod,x2)
LST = LazySegTree(N,X_func,A_func,operate,(0,0),(1,0))
LST.build([(1,1)]*N)
for _ in range(Q):
l,r,d = MI()
LST.operate_range(l-1,r,(0,d))
print((LST.fold(0,N)[0]))
| import sys
sys.setrecursionlimit(10**7)
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,Q = MI()
mod = 998244353
power = [1] # power[i] = 10**i
for i in range(N):
power.append((power[-1]*10) % mod)
t = pow(9,mod-2,mod) # 9 の逆数
class LazySegTree(): # モノイドに対して適用可能、Nが2冪でなくても良い
def __init__(self,N,X_func,A_func,operate,X_unit,A_unit):
self.N = N
self.X_func = X_func
self.A_func = A_func
self.operate = operate
self.X_unit = X_unit
self.A_unit = A_unit
self.X = [self.X_unit]*(2*self.N)
self.A = [self.A_unit]*(2*self.N)
self.size = [0]*(2*self.N)
def build(self,init_value): # 初期値を[N,2N)に格納
for i in range(self.N):
self.X[self.N+i] = init_value[i]
self.size[self.N+i] = 1
for i in range(self.N-1,0,-1):
self.X[i] = self.X_func(self.X[i << 1],self.X[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.X[i] = x
i >>= 1
while i:
self.X[i] = self.X_func(self.X[i << 1],self.X[i << 1 | 1])
i >>= 1
def eval_at(self,i): # i番目で作用を施した値を返す
return self.operate(self.X[i],self.A[i],self.size[i])
def eval_above(self,i): # i番目より上の値を再計算する
i >>= 1
while i:
self.X[i] = self.X_func(self.eval_at(i << 1),self.eval_at(i << 1 | 1))
i >>= 1
def propagate_at(self,i): # i番目で作用を施し、1つ下に作用の情報を伝える
self.X[i] = self.operate(self.X[i],self.A[i],self.size[i])
self.A[i << 1] = self.A_func(self.A[i << 1],self.A[i])
self.A[i << 1 | 1] = self.A_func(self.A[i << 1 | 1], self.A[i])
self.A[i] = self.A_unit
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.X_unit
vR = self.X_unit
while L < R:
if L & 1:
vL = self.X_func(vL,self.eval_at(L))
L += 1
if R & 1:
R -= 1
vR = self.X_func(self.eval_at(R),vR)
L >>= 1
R >>= 1
return self.X_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.A[L] = self.A_func(self.A[L],x)
L += 1
if R & 1:
R -= 1
self.A[R] = self.A_func(self.A[R],x)
L >>= 1
R >>= 1
self.eval_above(L0)
self.eval_above(R0)
def X_func(x,y):
x1,x2 = x
y1,y2 = y
return ((x1*power[y2]+y1) % mod,x2+y2)
def A_func(a,b):
if b == 0:
return a
return b
def operate(x,a,r): # 右作用
if a == 0:
return x
x1,x2 = x
return ((a*(power[x2]-1)*t) % mod,x2)
LST = LazySegTree(N,X_func,A_func,operate,(0,0),0)
LST.build([(1,1)]*N)
for _ in range(Q):
l,r,d = MI()
LST.operate_range(l-1,r,d)
print((LST.fold(0,N)[0]))
| p02538 |
MOD = 998244353
class LazySegmentTree: # from https://atcoder.jp/contests/practice2/submissions/16598122
__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)) >> 1
r0 = (r//(r&-r)-1) >> 1
while r0 > l0:
indices.append(r0)
r0 >>= 1
while l0 > r0:
indices.append(l0)
l0 >>= 1
while l0 and l0 != r0:
indices.append(r0)
r0 >>= 1
if l0 == r0:
break
indices.append(l0)
l0 >>= 1
while r0:
indices.append(r0)
r0 >>= 1
# 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&1:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r&1:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l >>= 1
r >>= 1
# recalculation
for i in indices:
self.data[i] = self.fmm(self.fmo(self.data[2*i], self.lazy[2*i]),
self.fmo(self.data[2*i+1], self.lazy[2*i+1]))
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l//(l&-l))//2
r0 = (r//(r&-r)-1)//2
while r0 > l0:
indices.append(r0)
r0 >>= 1
while l0 > r0:
indices.append(l0)
l0 >>= 1
while l0 and l0 != r0:
indices.append(r0)
r0 >>= 1
if l0 == r0:
break
indices.append(l0)
l0 >>= 1
while r0:
indices.append(r0)
r0 >>= 1
# propagation
for i in reversed(indices):
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l&1:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r&1:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l >>= 1
r >>= 1
return self.fmm(left_folded, right_folded)
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
import sys
sys.setrecursionlimit(311111)
# import numpy as np
ikimasu = sys.stdin.buffer.readline
ini = lambda: int(ins())
ina = lambda: list(map(int, ikimasu().split()))
ins = lambda: ikimasu().strip()
n,q = ina()
tmp = [(ModInt(1),ModInt(1)) for i in range(0,n)]
tmpx = ModInt(1)
tmpx1 = ModInt(1)
ten = []
one = []
for i in range(311111):
ten.append(tmpx)
one.append(tmpx1)
tmpx1*=10
tmpx1+=1
tmpx*=10
# print(ten)
def op(x1,x2):
val1,size1 = x1
val2,size2 = x2
size = size1+size2
val = val1*ten[size2]+val2
return val,size
e = (0,0)
def maptmp(s,f):
if(f == -1):
return s
else:
return f*one[s[1]-1],s[1]
def comp(g,f):
return f if f!=-1 else g
ident = -1
tmptree = LazySegmentTree(tmp,e,ident,op,maptmp,comp)
for _ in range(q):
l,r,x = ina()
tmptree.effect(l-1,r,x)
print((tmptree.folded(0,n)[0]))
if __name__ == "__main__":
main()
| MOD = 998244353
class LazySegmentTree: # from https://atcoder.jp/contests/practice2/submissions/16598122
__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)) >> 1
r0 = (r//(r&-r)-1) >> 1
while r0 > l0:
indices.append(r0)
r0 >>= 1
while l0 > r0:
indices.append(l0)
l0 >>= 1
while l0 and l0 != r0:
indices.append(r0)
r0 >>= 1
if l0 == r0:
break
indices.append(l0)
l0 >>= 1
while r0:
indices.append(r0)
r0 >>= 1
# 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&1:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r&1:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l >>= 1
r >>= 1
# recalculation
for i in indices:
self.data[i] = self.fmm(self.fmo(self.data[2*i], self.lazy[2*i]),
self.fmo(self.data[2*i+1], self.lazy[2*i+1]))
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l//(l&-l))//2
r0 = (r//(r&-r)-1)//2
while r0 > l0:
indices.append(r0)
r0 >>= 1
while l0 > r0:
indices.append(l0)
l0 >>= 1
while l0 and l0 != r0:
indices.append(r0)
r0 >>= 1
if l0 == r0:
break
indices.append(l0)
l0 >>= 1
while r0:
indices.append(r0)
r0 >>= 1
# propagation
for i in reversed(indices):
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l&1:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r&1:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l >>= 1
r >>= 1
return self.fmm(left_folded, right_folded)
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
import sys
sys.setrecursionlimit(311111)
# import numpy as np
ikimasu = sys.stdin.buffer.readline
ini = lambda: int(ins())
ina = lambda: list(map(int, ikimasu().split()))
ins = lambda: ikimasu().strip()
n,q = ina()
tmp = [(1,1) for i in range(0,n)]
tmpx = 1
tmpx1 = 1
ten = []
one = []
for i in range(311111):
ten.append(tmpx)
one.append(tmpx1)
tmpx1*=10
tmpx1+=1
tmpx*=10
tmpx1%=MOD
tmpx%=MOD
# print(ten)
def op(x1,x2):
val1,size1 = x1
val2,size2 = x2
size = size1+size2
val = (val1*ten[size2])+val2
return val%MOD,size
e = (0,0)
def maptmp(s,f):
if(f == -1):
return s
else:
return f*one[s[1]-1]%MOD,s[1]
def comp(g,f):
return f if f!=-1 else g
ident = -1
tmptree = LazySegmentTree(tmp,e,ident,op,maptmp,comp)
for _ in range(q):
l,r,x = ina()
tmptree.effect(l-1,r,x)
print((tmptree.folded(0,n)[0]))
if __name__ == "__main__":
main()
| p02538 |
#!/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
size = get_size(pos) // 2
table[pos] = binop(
table[pos * 2],
table[pos * 2 + 1],
size
)
def full_up(table, binop):
for pos in range(NONLEAF_SIZE - 1, 0, -1):
size = get_size(pos) // 2
table[pos] = binop(
table[2 * pos],
table[2 * pos + 1],
size)
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
right_size = 0
while left < right:
if left & 1:
size = get_size(left)
ret_left = binop(ret_left, table[left], size)
# debug("size, ret_left", size, ret_left)
left += 1
if right & 1:
right -= 1
ret_right = binop(table[right], ret_right, right_size)
right_size += get_size(right)
# debug("right_size, ret_right", right_size, ret_right)
left //= 2
right //= 2
return binop(ret_left, ret_right, right_size)
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())
set_width(N + 1)
value_unity = 0
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE + N] = [1] * N
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
cache = {}
i = 1
p = 1
step = 10
while i <= N:
cache[i] = p
p = (p * step + p) % MOD
step = (step * step) % MOD
i *= 2
def action_force(action, value, size):
if action == action_unity:
return value
# return int(str(action) * size)
return (cache[size] * action) % MOD
def action_composite(new_action, old_action):
if new_action == action_unity:
return old_action
return new_action
def value_binop(a, b, size):
# debug("a, b, size", a, b, size)
return (a * (10 ** size) + b) % MOD
full_up(value_table, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
for _q in range(Q):
l, r, d = map(int, input().split())
lazy_range_update(
action_table, value_table, l - 1, r, d,
action_composite, action_force, action_unity, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
print(ret)
# tests
T1 = """
8 5
3 6 2
1 4 7
3 8 3
2 2 2
4 5 1
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
11222211
77772211
77333333
72333333
72311333
"""
T2 = """
200000 1
123 456 7
"""
TEST_T2 = """
>>> as_input(T2)
>>> main()
641437905
"""
T3 = """
4 4
1 1 2
1 2 3
1 3 4
1 4 5
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
2111
3311
4441
5555
"""
T4 = """
4 4
4 4 2
3 4 3
2 4 4
1 4 5
1112
1133
1444
5555
"""
TEST_T4 = """
>>> as_input(T4)
>>> main()
1112
1133
1444
5555
"""
T5 = """
9 3
1 9 1
1 9 5
1 9 9
"""
TEST_T5 = """
>>> as_input(T5)
>>> main()
111111111
555555555
1755646
"""
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
size = get_size(pos) // 2
table[pos] = binop(
table[pos * 2],
table[pos * 2 + 1],
size
)
def full_up(table, binop):
for pos in range(NONLEAF_SIZE - 1, 0, -1):
size = get_size(pos) // 2
table[pos] = binop(
table[2 * pos],
table[2 * pos + 1],
size)
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
right_size = 0
while left < right:
if left & 1:
size = get_size(left)
ret_left = binop(ret_left, table[left], size)
# debug("size, ret_left", size, ret_left)
left += 1
if right & 1:
right -= 1
ret_right = binop(table[right], ret_right, right_size)
right_size += get_size(right)
# debug("right_size, ret_right", right_size, ret_right)
left //= 2
right //= 2
return binop(ret_left, ret_right, right_size)
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())
set_width(N + 1)
value_unity = 0
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE + N] = [1] * N
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
cache11 = {}
i = 1
p = 1
step = 10
while i <= N:
cache11[i] = p
p = (p * step + p) % MOD
step = (step * step) % MOD
i *= 2
cache10 = {0: 1}
i = 1
p = 10
while i <= N:
cache10[i] = p
p = (p * 10) % MOD
i += 1
def action_force(action, value, size):
if action == action_unity:
return value
# return int(str(action) * size)
return (cache11[size] * action) % MOD
def action_composite(new_action, old_action):
if new_action == action_unity:
return old_action
return new_action
def value_binop(a, b, size):
# debug("a, b, size", a, b, size)
# return (a * (10 ** size) + b) % MOD
return (a * cache10[size] + b) % MOD
full_up(value_table, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
for _q in range(Q):
l, r, d = map(int, input().split())
lazy_range_update(
action_table, value_table, l - 1, r, d,
action_composite, action_force, action_unity, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
print(ret)
# tests
T1 = """
8 5
3 6 2
1 4 7
3 8 3
2 2 2
4 5 1
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
11222211
77772211
77333333
72333333
72311333
"""
T2 = """
200000 1
123 456 7
"""
TEST_T2 = """
>>> as_input(T2)
>>> main()
641437905
"""
T3 = """
4 4
1 1 2
1 2 3
1 3 4
1 4 5
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
2111
3311
4441
5555
"""
T4 = """
4 4
4 4 2
3 4 3
2 4 4
1 4 5
1112
1133
1444
5555
"""
TEST_T4 = """
>>> as_input(T4)
>>> main()
1112
1133
1444
5555
"""
T5 = """
9 3
1 9 1
1 9 5
1 9 9
"""
TEST_T5 = """
>>> as_input(T5)
>>> main()
111111111
555555555
1755646
"""
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()
| p02538 |
"""
Generalized Lazy Segment Tree
- Range set, Rande minimum
- Range add, Range sum
- Rande add, Range minimum
- Rande set, Rande sum
- Range Affine, Range sum
- Range nagate of 0/1 sequence, Range calculation of inversion(TENTOUSUU)
"""
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 full_up(value_table, value_binop):
for i in range(NONLEAF_SIZE - 1, 0, -1):
value_table[i] = value_binop(
value_table[2 * i],
value_table[2 * i + 1])
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 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])
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)
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, value_binop, value_unity):
ret_left = value_unity
ret_right = value_unity
left += NONLEAF_SIZE
right += NONLEAF_SIZE
while left < right:
if left & 1:
ret_left = value_binop(ret_left, table[left])
left += 1
if right & 1:
right -= 1
ret_right = value_binop(table[right], ret_right)
left //= 2
right //= 2
return value_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 debugprint(xs, minsize=0, maxsize=None):
import sys
global DEPTH
strs = [str(x) for x in xs]
if maxsize != None:
for i in range(NONLEAF_SIZE, SEGTREE_SIZE):
strs[i] = strs[i][:maxsize]
s = max(len(s) for s in strs[NONLEAF_SIZE:])
if s > minsize:
minsize = s
result = ["|"] * DEPTH
level = 0
next_level = 2
for i in range(1, SEGTREE_SIZE):
if i == next_level:
level += 1
next_level *= 2
width = ((minsize + 1) << (DEPTH - 1 - level)) - 1
result[level] += strs[i].center(width) + "|"
print(*result, sep="\n", file=sys.stderr)
def init_from_values(values, value_binop, value_unity):
N = len(values)
set_width(N)
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE + len(values)] = values
full_up(value_table, value_binop)
return value_table
def set_items(table, xs):
for i, x in enumerate(xs, NONLEAF_SIZE):
table[i] = x
def usage():
from operator import add
N = 100
set_width(N)
value_unity = 0
value_table = [0] * SEGTREE_SIZE
value_binop = add
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
def action_force(action, value, size):
if action == action_unity:
return value
return action * size
def action_composite(new_action, old_action):
if new_action != action_unity:
return new_action
return old_action
start = 12
end = 34
action = 42
lazy_range_update(
action_table, value_table, start, end,
action, action_composite, action_force, action_unity, value_binop)
print(lazy_range_reduce(
action_table, value_table, start, end,
action_composite, action_force, action_unity, value_binop, value_unity))
# samples for action
def action_set_min(action_unity=None):
def action_force(action, value, size):
if action == action_unity:
return value
return action
def action_composite(new_action, old_action):
if new_action != action_unity:
return new_action
return old_action
return action_unity, action_force, action_composite
def action_set_sum(action_unity=None):
def action_force(action, value, size):
if action == action_unity:
return value
return action * size
def action_composite(new_action, old_action):
if new_action != action_unity:
return new_action
return old_action
return action_unity, action_force, action_composite
def action_add_sum(action_unity=0):
def action_force(action, value, size):
return action * size + value
def action_composite(new_action, old_action):
return new_action + old_action
return action_unity, action_force, action_composite
# --- end of library ---
def debug(*x):
import sys
print(*x, file=sys.stderr)
def mainF():
"""
Range set, Rande minimum
RMQ and RUQ
https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_F
"""
N, Q = map(int, input().split())
set_width(N)
value_unity = (1 << 31) - 1
value_table = [value_unity] * SEGTREE_SIZE
action_unity, action_force, action_composite = action_set_min()
action_table = [action_unity] * SEGTREE_SIZE
for _ in range(Q):
q, *args = map(int, input().split())
if q == 0:
# update
left, right, value = args
right += 1 # include right
lazy_range_update(
action_table, value_table, left, right, value,
action_composite, action_force, action_unity, min)
else:
# find
left, right = args
print(lazy_range_reduce(
action_table, value_table, left, right + 1,
action_composite, action_force, action_unity, min, value_unity))
T1F = """
3 5
0 0 1 1
0 1 2 3
0 2 2 2
1 0 2
1 1 2
"""
TEST_T1F = """
>>> as_input(T1F)
>>> mainF()
1
2
"""
T2F = """
1 3
1 0 0
0 0 0 5
1 0 0
"""
TEST_T2F = """
>>> as_input(T2F)
>>> mainF()
2147483647
5
"""
T3F = """
8 10
0 1 6 5
0 2 7 2
0 2 5 7
1 3 3
1 2 4
1 0 3
1 5 7
1 2 6
0 3 7 9
1 2 6
"""
TEST_T3F = """
>>> as_input(T3F)
>>> mainF()
7
7
5
2
2
7
"""
T4F = """
15 3
0 1 6 5
0 2 7 2
1 6 7
"""
TEST_T4F = """
>>> as_input(T4F)
>>> mainF()
2
"""
def mainG():
"""
Range add, Range sum
RSQ and RAQ
https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_G
"""
from operator import add
# parse input
N, Q = map(int, input().split())
set_width(N)
value_unity = 0
value_table = [value_unity] * SEGTREE_SIZE
value_binop = add
action_unity, action_force, action_composite = action_add_sum()
action_table = [action_unity] * SEGTREE_SIZE
for _ in range(Q):
q, *args = map(int, input().split())
if q == 0:
# add
s, t, value = args
s -= 1
lazy_range_update(
action_table, value_table, s, t, value,
action_composite, action_force, action_unity, value_binop)
else:
# getSum
s, t = args
print(lazy_range_reduce(
action_table, value_table, s - 1, t,
action_composite, action_force, action_unity, value_binop, value_unity))
T1G = """
3 5
0 1 2 1
0 2 3 2
0 3 3 3
1 1 2
1 2 3
"""
TEST_T1G = """
>>> as_input(T1G)
>>> mainG()
4
8
"""
T2G = """
4 3
1 1 4
0 1 4 1
1 1 4
"""
TEST_T2G = """
>>> as_input(T2G)
>>> mainG()
0
4
"""
def mainH():
"""
Rande add, Range minimum
RMQ and RAQ
https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_H
"""
# parse input
N, Q = map(int, input().split())
set_width(N)
value_unity = 10 ** 9
value_table = [value_unity] * SEGTREE_SIZE
set_items(value_table, [0] * N)
full_up(value_table, min)
value_binop = min
action_unity = 0
action_table = [action_unity] * SEGTREE_SIZE
def action_force(action, value, size):
return action + value
def action_composite(new_action, old_action):
return new_action + old_action
for _ in range(Q):
q, *args = map(int, input().split())
if q == 0:
# add
s, t, value = args
t += 1
lazy_range_update(
action_table, value_table, s, t, value,
action_composite, action_force, action_unity, value_binop)
else:
# getSum
s, t = args
print(lazy_range_reduce(
action_table, value_table, s, t + 1,
action_composite, action_force, action_unity, value_binop, value_unity))
T1H = """
6 7
0 1 3 1
0 2 4 -2
1 0 5
1 0 1
0 3 5 3
1 3 4
1 0 5
"""
TEST_T1H = """
>>> as_input(T1H)
>>> mainH()
-2
0
1
-1
"""
def mainI():
"""
Rande set, Rande sum
RSQ and RUQ
https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_I
"""
# parse input
from operator import add
N, Q = map(int, input().split())
set_width(N)
value_unity = 0
value_table = [0] * SEGTREE_SIZE
value_binop = add
action_unity, action_force, action_composite = action_set_sum()
action_table = [action_unity] * SEGTREE_SIZE
for _ in range(Q):
q, *args = map(int, input().split())
if q == 0:
# update
s, t, value = args
t += 1
lazy_range_update(
action_table, value_table, s, t, value,
action_composite, action_force, action_unity, value_binop)
else:
# getSum
s, t = args
print(lazy_range_reduce(
action_table, value_table, s, t + 1,
action_composite, action_force, action_unity, value_binop, value_unity))
T1I = """
6 7
0 1 3 1
0 2 4 -2
1 0 5
1 0 1
0 3 5 3
1 3 4
1 0 5
"""
TEST_T1I = """
>>> as_input(T1I)
>>> mainI()
-5
1
6
8
"""
def mainACLPC_K():
"""
Range Affine, Range sum
https://atcoder.jp/contests/practice2/tasks/practice2_k
Pack 2 values into an integer to avoid TLE
"""
MOD = 998244353
N, Q = map(int, input().split())
AS = list(map(int, input().split()))
set_width(N + 1) # include N
value_unity = 0
def value_binop(a, b):
return (a + b) % MOD
value_table = init_from_values(AS, value_binop, value_unity)
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
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))
TACLPC_K = """
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_TACLPC_K = """
>>> as_input(TACLPC_K)
>>> mainACLPC_K()
15
404
41511
4317767
"""
def mainACLPC_L():
"""
Range nagate of 0/1 sequence, Range calculation of inversion
https://atcoder.jp/contests/practice2/tasks/practice2_l
"""
N, Q = map(int, input().split())
AS = list(map(int, input().split()))
set_width(N) # include N
value_unity = (0, 0, 0)
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE +
len(AS)] = [(0, 1, 0) if a else (1, 0, 0) for a in AS]
def value_binop(a, b):
x1, y1, z1 = a
x2, y2, z2 = b
return (x1 + x2, y1 + y2, z1 + z2 + y1 * x2)
full_up(value_table, value_binop)
action_unity = False
action_table = [action_unity] * SEGTREE_SIZE
def action_force(action, value, size):
if action == action_unity:
return value
x, y, z = value
return (y, x, x * y - z)
def action_composite(new_action, old_action):
return new_action ^ old_action
for _q in range(Q):
q, *args = map(int, input().split())
if q == 1:
l, r = args
l -= 1 # 1-origin, r inclusive
lazy_range_update(
action_table, value_table, l, r, True,
action_composite, action_force, action_unity, value_binop)
else:
l, r = args
l -= 1 # 1-origin, r inclusive
print(lazy_range_reduce(
action_table, value_table, l, r,
action_composite, action_force, action_unity, value_binop, value_unity)[2])
TACLPC_L = """
5 5
0 1 0 0 1
2 1 5
1 3 4
2 2 5
1 1 3
2 1 2
"""
TEST_TACLPC_L = """
>>> as_input(TACLPC_L)
>>> mainACLPC_L()
2
0
1
"""
def main():
# parse input
MOD = 998244353
N, Q = map(int, input().split())
cache11 = {}
i = 1
p = 1
step = 10
while i <= N:
cache11[i] = p
p = (p * step + p) % MOD
step = (step * step) % MOD
i *= 2
cache10 = {0: 1}
i = 1
p = 10
while i <= N:
cache10[i] = p
p = (p * 10) % MOD
i += 1
# value_unity = (0, 0) # value, size
value_unity = 0
def value_binop(a, b):
# 1:
# return (a * (10 ** size) + b) % MOD
# 2:
# a, size_a = a
# b, size_b = b
# return (
# (a * cache10[size_b] + b) % MOD,
# size_a + size_b
# )
# 3:
value_a = a >> 32
size_a = a - (value_a << 32)
value_b = b >> 32
size_b = b - (value_b << 32)
value = (value_a * cache10[size_b] + value_b) % MOD
size = size_a + size_b
ret = (value << 32) + size
return ret
init_value = (1 << 32) + 1
value_table = init_from_values(
[init_value] * N,
value_binop,
value_unity
)
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
def action_force(action, value, size):
if action == action_unity:
return value
# 1:
# return int(str(action) * size)
# 2:
# return (
# (cache11[size] * action) % MOD,
# size
# )
# 3:
new_value = (cache11[size] * action) % MOD
ret = (new_value << 32) + size
return ret
def action_composite(new_action, old_action):
if new_action == action_unity:
return old_action
return new_action
full_up(value_table, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
for _q in range(Q):
l, r, d = map(int, input().split())
lazy_range_update(
action_table, value_table, l - 1, r, d,
action_composite, action_force, action_unity, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
value = ret >> 32
_size = ret - (value << 32)
print(value)
# tests
T1 = """
8 5
3 6 2
1 4 7
3 8 3
2 2 2
4 5 1
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
11222211
77772211
77333333
72333333
72311333
"""
T2 = """
200000 1
123 456 7
"""
TEST_T2 = """
>>> as_input(T2)
>>> main()
641437905
"""
T3 = """
4 4
1 1 2
1 2 3
1 3 4
1 4 5
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
2111
3311
4441
5555
"""
T4 = """
4 4
4 4 2
3 4 3
2 4 4
1 4 5
1112
1133
1444
5555
"""
TEST_T4 = """
>>> as_input(T4)
>>> main()
1112
1133
1444
5555
"""
T5 = """
9 3
1 9 1
1 9 5
1 9 9
"""
TEST_T5 = """
>>> as_input(T5)
>>> main()
111111111
555555555
1755646
"""
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
g = globals()
f = io.StringIO(s.strip())
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
if __name__ == "__main__":
import sys
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| """
Lazy Segment Tree: value_binop takes right node size
"""
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
right = pos * 2 + 1
size = get_size(right)
table[pos] = binop(
table[pos * 2],
table[right],
size
)
def full_up(table, binop):
for pos in range(NONLEAF_SIZE - 1, 0, -1):
right = pos * 2 + 1
size = get_size(right)
table[pos] = binop(
table[pos * 2],
table[right],
size)
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])
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)
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
right_size = 0
while left < right:
if left & 1:
size = get_size(left)
ret_left = binop(ret_left, table[left], size)
left += 1
if right & 1:
right -= 1
ret_right = binop(table[right], ret_right, right_size)
right_size += get_size(right)
left //= 2
right //= 2
return binop(ret_left, ret_right, right_size)
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 init_from_values(values, value_binop, value_unity):
N = len(values)
set_width(N)
value_table = [value_unity] * SEGTREE_SIZE
value_table[NONLEAF_SIZE:NONLEAF_SIZE + len(values)] = values
full_up(value_table, value_binop)
return value_table
# --- end of library ---
def debug(*x):
print(*x, file=sys.stderr)
def main():
# parse input
MOD = 998244353
N, Q = map(int, input().split())
cache11 = {}
i = 1
p = 1
step = 10
while i <= N:
cache11[i] = p
p = (p * step + p) % MOD
step = (step * step) % MOD
i *= 2
cache10 = {0: 1}
i = 1
p = 10
while i <= N:
cache10[i] = p
p = (p * 10) % MOD
i += 1
def action_force(action, value, size):
if action == action_unity:
return value
# return int(str(action) * size)
return (cache11[size] * action) % MOD
def action_composite(new_action, old_action):
if new_action == action_unity:
return old_action
return new_action
def value_binop(a, b, size):
# debug("a, b, size", a, b, size)
# return (a * (10 ** size) + b) % MOD
return (a * cache10[size] + b) % MOD
value_unity = 0
value_table = init_from_values([1] * N, value_binop, value_unity)
action_unity = None
action_table = [action_unity] * SEGTREE_SIZE
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
for _q in range(Q):
l, r, d = map(int, input().split())
lazy_range_update(
action_table, value_table, l - 1, r, d,
action_composite, action_force, action_unity, value_binop)
ret = lazy_range_reduce(
action_table, value_table, 0, N, action_composite, action_force, action_unity,
value_binop, value_unity)
print(ret)
# tests
T1 = """
8 5
3 6 2
1 4 7
3 8 3
2 2 2
4 5 1
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
11222211
77772211
77333333
72333333
72311333
"""
T2 = """
200000 1
123 456 7
"""
TEST_T2 = """
>>> as_input(T2)
>>> main()
641437905
"""
T3 = """
4 4
1 1 2
1 2 3
1 3 4
1 4 5
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
2111
3311
4441
5555
"""
T4 = """
4 4
4 4 2
3 4 3
2 4 4
1 4 5
1112
1133
1444
5555
"""
TEST_T4 = """
>>> as_input(T4)
>>> main()
1112
1133
1444
5555
"""
T5 = """
9 3
1 9 1
1 9 5
1 9 9
"""
TEST_T5 = """
>>> as_input(T5)
>>> main()
111111111
555555555
1755646
"""
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")
if __name__ == "__main__":
import sys
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| p02538 |
import sys
def input(): return sys.stdin.readline().rstrip()
# SegmentTree
class SegmentTree:
def __init__(self, n, p, unit, f, g, h):
num = 2**((n-1).bit_length())
seg = [unit]*(num*2)
self.lazy = [None]*(num*2)
for i in range(n):
seg[num+i] = p[i]
for i in range(num-1, 0, -1):
seg[i] = f(seg[i << 1], seg[(i << 1)+1])
self.num = num
self.seg = seg
self.unit = unit
self.flag = False
self.f = f
self.g = g
self.h = h
def gindex(self, l, r):
l += self.num
r += self.num
lm = (l//(l & -l)) >> 1
rm = (r//(r & -r)) >> 1
mm = max(lm, rm)
r -= 1
while l < r:
if r <= rm:
yield r
if l <= lm:
yield l
l >>= 1
r >>= 1
while l:
if l <= mm:
yield l
l >>= 1
def propagates(self, ids):
num = self.num
g = self.g
h = self.h
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
# ここ！！！！！！！！！！！！！
# ここ！！！！！！！！！！！！！
newv = v
# ここ！！！！！！！！！！！！！
# ここ！！！！！！！！！！！！！
if (i << 1) < num:
self.lazy[i << 1] = h(self.lazy[i << 1], newv)
self.lazy[(i << 1)+1] = h(self.lazy[(i << 1)+1], newv)
self.seg[i << 1] = g(self.seg[i << 1], newv,i<<1)
self.seg[(i << 1)+1] = g(self.seg[(i << 1)+1], newv,(i<<1)+1)
self.lazy[i] = None
def query(self, l, r):
f = self.f
if self.flag:
*ids, = self.gindex(l, r)
self.propagates(ids)
ansl = ansr = self.unit
l += self.num
r += self.num-1
if l == r:
return self.seg[l]
while l < r:
if l & 1:
ansl = f(ansl, self.seg[l])
l += 1
if r & 1 == 0:
ansr = f(self.seg[r], ansr)
r -= 1
l >>= 1
r >>= 1
if l == r:
ansl = f(ansl, self.seg[l])
return f(ansl, ansr)
def update1(self, i, x):
i += self.num
f = self.f
self.seg[i] = x
while i:
i >>= 1
self.seg[i] = f(self.seg[i << 1], self.seg[(i << 1)+1])
def update2(self, l, r, x):
self.flag = True
*ids, = self.gindex(l, r)
self.propagates(ids)
num = self.num
f = self.f
g = self.g
h = self.h
l += num
r += num-1
if l == r:
self.seg[l] = g(self.seg[l], x,l)
for i in ids:
self.seg[i] = f(self.seg[i << 1], self.seg[(i << 1)+1])
return
while l < r:
if l & 1:
if l < num:
self.lazy[l] = h(self.lazy[l], x)
self.seg[l] = g(self.seg[l], x,l)
l += 1
if r & 1 == 0:
if r < num:
self.lazy[r] = h(self.lazy[r], x)
self.seg[r] = g(self.seg[r], x,r)
r -= 1
l >>= 1
r >>= 1
if l == r:
self.lazy[l] = h(self.lazy[l], x)
self.seg[l] = g(self.seg[l], x,l)
for i in ids:
self.seg[i] = f(self.seg[i << 1], self.seg[(i << 1)+1])
def update(self, i, x):
if type(i) is int:
self.update1(i, x)
else:
self.update2(i[0], i[1], x)
mod=998244353
n,q=list(map(int,input().split()))
num=2**((n-1).bit_length())
d=[1]
for i in range(n-1):
d.append(d[-1]*10%mod)
d=d[::-1]
d+=[0]*len(d)
e=[0]+d[:]
m=len(e)
for i in range(m-1):
e[i+1]=(e[i]+e[i+1])%mod
def f(a,b):
return a+b
def g(x,y,i):
if y==None:return x
b=1<<(i.bit_length()-1)
i-=b
l=(num//b)*i
r=l+num//b
return (e[r]-e[l])*y%mod
def h(x,y):
if y==None:return x
return y
seg=SegmentTree(n,d,0,f,g,h)
for _ in range(q):
l,r,d=list(map(int,input().split()))
seg.update2(l-1,r,d)
print((seg.query(0,n)%mod)) | import sys
def input(): return sys.stdin.readline().rstrip()
# LazySegmentTree
class LazySegmentTree:
# f(X, X) -> X
# g(X, M) -> X
# h(M, M) -> M
__slots__ = ["n", "num", "seg", "x_unit", "m_unit", "f", "g", "h", "lazy"]
def __init__(self, n, p, x_unit, m_unit, f, g, h):
self.n = n
self.num = 2**((n-1).bit_length())
self.seg = p*2
self.x_unit = x_unit
self.m_unit = m_unit
self.f = f
self.g = g
self.h = h
for i in range(self.n-1, 0, -1):
self.seg[i] = self.f(self.seg[i<<1], self.seg[(i<<1)+1])
self.lazy = [m_unit] * (self.n * 2)
def update(self, l, r, x):
l += self.num
r += self.num
ll = l // (l & -l)
rr = r // (r & -r) - 1
for shift in range(ll.bit_length()-1, 0, -1):
i = ll >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i],i)
self.lazy[i] = self.m_unit
for shift in range(rr.bit_length()-1, 0, -1):
i = rr >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i],i)
self.lazy[i] = self.m_unit
while l < r:
if l & 1:
self.lazy[l] = self.h(self.lazy[l], x)
l += 1
if r & 1:
r -= 1
self.lazy[r] = self.h(self.lazy[r], x)
l >>= 1
r >>= 1
while ll > 1:
ll >>= 1
self.seg[ll] = self.f(self.g(self.seg[ll << 1], self.lazy[ll << 1],ll << 1), self.g(self.seg[(ll << 1)+1], self.lazy[(ll << 1)+1],(ll << 1)+1))
self.lazy[ll] = self.m_unit
while rr > 1:
rr >>= 1
self.seg[rr] = self.f(self.g(self.seg[rr << 1], self.lazy[rr << 1],rr << 1), self.g(self.seg[(rr << 1)+1], self.lazy[(rr << 1)+1],(rr << 1)+1))
self.lazy[rr] = self.m_unit
def query(self, l, r):
l += self.num
r += self.num
ll = l // (l & -l)
rr = r // (r & -r) - 1
for shift in range(ll.bit_length()-1, 0, -1):
i = ll >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i],i)
self.lazy[i] = self.m_unit
for shift in range(rr.bit_length()-1, 0, -1):
i = rr >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i],i)
self.lazy[i] = self.m_unit
ans_l = ans_r = self.x_unit
while l < r:
if l & 1:
ans_l = self.f(ans_l, self.g(self.seg[l], self.lazy[l],l))
l += 1
if r & 1:
r -= 1
ans_r = self.f(self.g(self.seg[r], self.lazy[r],r), ans_r)
l >>= 1
r >>= 1
return self.f(ans_l, ans_r)
mod=998244353
n,q=list(map(int,input().split()))
num=2**((n-1).bit_length())
d=[1]
for i in range(n-1):
d.append(d[-1]*10%mod)
d=d[::-1]
d+=[0]*(num-len(d))
e=[0]+d[:]
for i in range(num):
e[i+1]=(e[i]+e[i+1])%mod
def f(a,b):
return a+b
def g(x,y,i):
if y==None:return x
b=1<<(i.bit_length()-1)
i-=b
l=(num//b)*i
r=l+num//b
return (e[r]-e[l])*y%mod
def h(x,y):
if y==None:return x
return y
seg=LazySegmentTree(num,d,0,None,f,g,h)
for _ in range(q):
l,r,d=list(map(int,input().split()))
seg.update(l-1,r,d)
print((seg.query(0,n)%mod)) | p02538 |
import sys
def input(): return sys.stdin.readline().rstrip()
# LazySegmentTree
class LazySegmentTree:
# f(X, X) -> X
# g(X, M) -> X
# h(M, M) -> M
__slots__ = ["n", "seg", "x_unit", "m_unit", "f", "g", "h", "lazy"]
def __init__(self, n, p, x_unit, m_unit, f, g, h):
self.n = n
self.seg = p*2
self.x_unit = x_unit
self.m_unit = m_unit
self.f = f
self.g = g
self.h = h
for i in range(self.n-1, 0, -1):
self.seg[i] = self.f(self.seg[i<<1], self.seg[(i<<1)+1])
self.lazy = [m_unit] * (self.n * 2)
def update(self, l, r, x):
l += self.n
r += self.n
ll = l // (l & -l)
rr = r // (r & -r) - 1
for shift in range(ll.bit_length()-1, 0, -1):
i = ll >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
for shift in range(rr.bit_length()-1, 0, -1):
i = rr >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
while l < r:
if l & 1:
self.lazy[l] = self.h(self.lazy[l], x)
l += 1
if r & 1:
r -= 1
self.lazy[r] = self.h(self.lazy[r], x)
l >>= 1
r >>= 1
while ll > 1:
ll >>= 1
self.seg[ll] = self.f(self.g(self.seg[ll << 1], self.lazy[ll << 1]), self.g(self.seg[(ll << 1)+1], self.lazy[(ll << 1)+1]))
self.lazy[ll] = self.m_unit
while rr > 1:
rr >>= 1
self.seg[rr] = self.f(self.g(self.seg[rr << 1], self.lazy[rr << 1]), self.g(self.seg[(rr << 1)+1], self.lazy[(rr << 1)+1]))
self.lazy[rr] = self.m_unit
def query(self, l, r):
l += self.n
r += self.n
ll = l // (l & -l)
rr = r // (r & -r) - 1
for shift in range(ll.bit_length()-1, 0, -1):
i = ll >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
for shift in range(rr.bit_length()-1, 0, -1):
i = rr >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
ans_l = ans_r = self.x_unit
while l < r:
if l & 1:
ans_l = self.f(ans_l, self.g(self.seg[l], self.lazy[l]))
l += 1
if r & 1:
r -= 1
ans_r = self.f(self.g(self.seg[r], self.lazy[r]), ans_r)
l >>= 1
r >>= 1
return self.f(ans_l, ans_r)
# X(要素) -> sum*200001+(文字列の長さ)
# (tuple,listで持つと2倍くらい遅くなるのでintにぶち込みます。多倍長最高！)
# M(作用) -> 置き換える数字
mod=998244353
n,q=list(map(int,input().split()))
num=2**((n-1).bit_length())
p=[]
for i in range(num):
if i<n:
p.append(200002)
else:
p.append(0)
digit=[1]
for _ in range(num):
digit.append(digit[-1]*10%mod)
inv9=pow(9,mod-2,mod)
def f(a,b):
asum,alen=divmod(a,200001)
bsum,blen=divmod(b,200001)
return ((digit[blen]*asum+bsum)%mod)*200001+alen+blen
def g(x,y):
if y is None:
return x
_,xlen=divmod(x,200001)
return ((digit[xlen]-1)*inv9*y%mod)*200001+xlen
def h(x,y):
if y is None:
return x
return y
seg=LazySegmentTree(num,p,0,None,f,g,h)
for _ in range(q):
l,r,d=list(map(int,input().split()))
seg.update(l-1,r,d)
ans,_=divmod(seg.query(0,n),200001)
print(ans) | import sys
def input(): return sys.stdin.readline().rstrip()
class LazySegmentTree:
__slots__ = ["n", "seg", "x_unit", "m_unit", "f", "g", "h", "lazy"]
def __init__(self, n, p, x_unit, m_unit, f, g, h):
self.n = n
self.seg = p*2
self.x_unit = x_unit
self.m_unit = m_unit
self.f = f
self.g = g
self.h = h
for i in range(self.n-1, 0, -1):
self.seg[i] = self.f(self.seg[i<<1], self.seg[(i<<1)+1])
self.lazy = [m_unit] * (self.n * 2)
def update(self, l, r, x):
l += self.n
r += self.n
ll = l // (l & -l)
rr = r // (r & -r) - 1
for shift in range(ll.bit_length()-1, 0, -1):
i = ll >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
for shift in range(rr.bit_length()-1, 0, -1):
i = rr >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
while l < r:
if l & 1:
self.lazy[l] = self.h(self.lazy[l], x)
l += 1
if r & 1:
r -= 1
self.lazy[r] = self.h(self.lazy[r], x)
l >>= 1
r >>= 1
while ll > 1:
ll >>= 1
self.seg[ll] = self.f(self.g(self.seg[ll << 1], self.lazy[ll << 1]), self.g(self.seg[(ll << 1)+1], self.lazy[(ll << 1)+1]))
self.lazy[ll] = self.m_unit
while rr > 1:
rr >>= 1
self.seg[rr] = self.f(self.g(self.seg[rr << 1], self.lazy[rr << 1]), self.g(self.seg[(rr << 1)+1], self.lazy[(rr << 1)+1]))
self.lazy[rr] = self.m_unit
def query(self, l, r):
l += self.n
r += self.n
ll = l // (l & -l)
rr = r // (r & -r) - 1
for shift in range(ll.bit_length()-1, 0, -1):
i = ll >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
for shift in range(rr.bit_length()-1, 0, -1):
i = rr >> shift
self.lazy[i << 1] = self.h(self.lazy[i << 1], self.lazy[i])
self.lazy[(i << 1)+1] = self.h(self.lazy[(i << 1)+1], self.lazy[i])
self.seg[i] = self.g(self.seg[i], self.lazy[i])
self.lazy[i] = self.m_unit
ans_l = ans_r = self.x_unit
while l < r:
if l & 1:
ans_l = self.f(ans_l, self.g(self.seg[l], self.lazy[l]))
l += 1
if r & 1:
r -= 1
ans_r = self.f(self.g(self.seg[r], self.lazy[r]), ans_r)
l >>= 1
r >>= 1
return self.f(ans_l, ans_r)
mod=998244353
n,q=list(map(int,input().split()))
digit=[1]
for _ in range(n):
digit.append(digit[-1]*10%mod)
inv9=pow(9,mod-2,mod)
def f(a,b):
asum,alen=divmod(a,200001)
bsum,blen=divmod(b,200001)
return ((digit[blen]*asum+bsum)%mod)*200001+alen+blen
def g(x,y):
if y is None:
return x
_,xlen=divmod(x,200001)
return ((digit[xlen]-1)*inv9*y%mod)*200001+xlen
def h(x,y):
if y is None:
return x
return y
seg=LazySegmentTree(n,[200002]*n,0,None,f,g,h)
for _ in range(q):
l,r,d=list(map(int,input().split()))
seg.update(l-1,r,d)
print((seg.query(0,n)//200001))
| p02538 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
def e():
# (v, b)
return (0, 0)
def op(sl, sr):
# print(sl, sr)
return ((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
if fl[0] == 0:
return sr
return ((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
if fl[1] > fr[1]:
return fl
return fr
def im():
return (0, -1)
@mt
def slv(N, Q, LRQ):
A = [(pow(10, N-i-1, M), pow(10, N-i-1, M)) for i in range(N)]
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, d) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, (d, i))
ans.append(st.prod(0, N)[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
def e():
# (v, b)
return (0, 0)
def op(sl, sr):
# print(sl, sr)
return ((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
if fl[0] == 0:
return sr
return ((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
if fl[1] > fr[1]:
return fl
return fr
def im():
return (0, -1)
@mt
def slv(N, Q, LRQ):
A = [(pow(10, N-i-1, M), pow(10, N-i-1, M)) for i in range(N)]
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, d) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, (d, i))
ans.append(st.prod(0, N)[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| p02538 |
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
def e():
# (v, b)
return (0, 0)
def op(sl, sr):
# print(sl, sr)
return ((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
if fl[0] == 0:
return sr
return ((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
if fl[1] > fr[1]:
return fl
return fr
def im():
return (0, -1)
@mt
def slv(N, Q, LRQ):
A = [(pow(10, N-i-1, M), pow(10, N-i-1, M)) for i in range(N)]
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, d) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, (d, i))
ans.append(st.prod(0, N)[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
def e():
# (v, b)
return (0, 0)
def op(sl, sr):
# print(sl, sr)
return ((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
if fl[0] == 0:
return sr
return ((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
if fl[1] > fr[1]:
return fl
return fr
def im():
return (0, -1)
@mt
def slv(N, Q, LRQ):
# A = [(pow(10, N-i-1, M), pow(10, N-i-1, M)) for i in range(N)]
A = []
for i in range(N):
v = pow(10, N-i-1, M)
A.append((v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, d) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, (d, i))
ans.append(st.prod(0, N)[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| p02538 |
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
def ser(a, b):
return (a << 32) + b
def des(v):
m = 1 << 32
m -= 1
return v >> 32, v & m
def e():
return 0
def op(sl, sr):
sl = des(sl)
sr = des(sr)
return ser((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
fl = des(fl)
if fl[0] == 0:
return sr
sr = des(sr)
return ser((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
fl2 = des(fl)
fr2 = des(fr)
if fl2[1] > fr2[1]:
return fl
return fr
def im():
return 0
@mt
def slv(N, Q, LRQ):
A = []
for i in range(N):
v = pow(10, N-i-1, M)
v %= M
A.append(ser(v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, q) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, ser(q, i))
ans.append(des(st.prod(0, N))[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
def ser(a, b):
return (a << 32) + b
m = 1 << 32
m -= 1
def des(v):
return v >> 32, v & m
def e():
return 0
def op(sl, sr):
sl = des(sl)
sr = des(sr)
return ser((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
fl = des(fl)
if fl[0] == 0:
return sr
sr = des(sr)
return ser((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
fl2 = des(fl)
fr2 = des(fr)
if fl2[1] > fr2[1]:
return fl
return fr
def im():
return 0
@mt
def slv(N, Q, LRQ):
A = []
for i in range(N):
v = pow(10, N-i-1, M)
v %= M
A.append(ser(v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, q) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, ser(q, i))
ans.append(des(st.prod(0, N))[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| p02538 |
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
@mt
def slv(N, Q, LRQ):
M = 998244353
def ser(a, b):
return (a << 32) + b
m = 1 << 32
m -= 1
def des(v):
return v >> 32, v & m
def e():
return 0
def op(sl, sr):
sl = des(sl)
sr = des(sr)
return ser((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
fl = des(fl)
if fl[0] == 0:
return sr
sr = des(sr)
return ser((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
fl2 = des(fl)
fr2 = des(fr)
if fl2[1] > fr2[1]:
return fl
return fr
def im():
return 0
A = []
for i in range(N):
v = pow(10, N-i-1, M)
v %= M
A.append(ser(v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, q) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, ser(q, i))
ans.append(des(st.prod(0, N))[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
m = 1 << 32
m -= 1
def ser(a, b):
return (a << 32) + b
def des(v):
return v >> 32, v & m
def e():
return 0
def op(sl, sr):
sl = des(sl)
sr = des(sr)
return ser((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
fl = des(fl)
if fl[0] == 0:
return sr
sr = des(sr)
return ser((sr[1]*fl[0]) % M, sr[1])
def composition(fl, fr):
fl2 = des(fl)
fr2 = des(fr)
if fl2[1] > fr2[1]:
return fl
return fr
def im():
return 0
@mt
def slv(N, Q, LRQ):
A = []
for i in range(N):
v = pow(10, N-i-1, M)
v %= M
A.append(ser(v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, q) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, ser(q, i))
ans.append(des(st.prod(0, N))[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| p02538 |
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
m = 1 << 32
m -= 1
def ser(a, b):
return (a << 32) + b
def des(v):
return v >> 32, v & m
def e():
return 0
def op(sl, sr):
sl = des(sl)
sr = des(sr)
return ser((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
if fl == 0:
return sr
sr = des(sr)
return ser((sr[1]*fl) % M, sr[1])
def composition(fl, fr):
if fl == 0:
return fr
return fl
def im():
return 0
@mt
def slv(N, Q, LRQ):
A = []
for i in range(N):
v = pow(10, N-i-1, M)
v %= M
A.append(ser(v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for i, (l, r, q) in enumerate(LRQ, start=1):
l -= 1
st.apply(l, r, q)
ans.append(des(st.prod(0, N))[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
readline = sys.stdin.buffer.readline
# readline = sys.stdin.readline
INF = 1 << 60
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
class LazySegmentTree():
def __init__(self, op, e, mapping, composition, im, init_array):
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.im = im
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 = [im() 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, r2 = l, 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, r = l2, 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.im()
M = 998244353
m = 1 << 32
m -= 1
def ser(a, b):
return (a << 32) + b
def des(v):
return v >> 32, v & m
def e():
return 0
def op(sl, sr):
sl = des(sl)
sr = des(sr)
return ser((sl[0] + sr[0]) % M, (sl[1] + sr[1]) % M)
def mapping(fl, sr):
if fl == 0:
return sr
sr = des(sr)
return ser((sr[1]*fl) % M, sr[1])
def composition(fl, fr):
return fr if fl ==0 else fl
def im():
return 0
@mt
def slv(N, Q, LRQ):
A = []
for i in range(N):
v = pow(10, N-i-1, M)
v %= M
A.append(ser(v, v))
st = LazySegmentTree(op, e, mapping, composition, im, A)
ans = []
for l, r, q in LRQ:
l -= 1
st.apply(l, r, q)
ans.append(des(st.prod(0, N))[0])
return ans
def main():
N, Q = read_int_n()
LRQ = [read_int_n() for _ in range(Q)]
print(*slv(N, Q, LRQ), sep='\n')
if __name__ == '__main__':
main()
| p02538 |
class LazySegmentTree():
def __init__(self, n, f, g, h, ef, eh):
"""
:param n: 配列の要素数
:param f: 取得半群の元同士の積を定義
:param g: 更新半群の元 xh が配列上の実際の値にどのように作用するかを定義
:param h: 更新半群の元同士の積を定義 （更新半群の元を xh と表記）
:param x: 配列の各要素の値。treeの葉以外は xf(x1,x2,...)
"""
self.n = n
self.f = f
self.g = lambda xh, x: g(xh, x) if xh != eh else x
self.h = h
self.ef = ef
self.eh = eh
l = (self.n - 1).bit_length()
self.size = 1 << l
self.tree = [self.ef] * (self.size << 1)
self.lazy = [self.eh] * ((self.size << 1) + 1)
self.plt_cnt = 0
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.f(self.tree[i<<1], self.tree[(i<<1)|1])
def update(self, i, x):
"""
i 番目の要素を x に更新する
"""
i += self.size
self.propagate_lazy(i)
self.tree[i] = x
self.lazy[i] = self.eh
self.propagate_tree(i)
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate_lazy(i)
return self.g(self.lazy[i], self.tree[i])
def update_range(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
if l >= r:
return
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate_lazy(l0)
self.propagate_lazy(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.h(x, self.lazy[r])
if l&1:
self.lazy[l] = self.h(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
self.propagate_tree(l0)
self.propagate_tree(r0-1)
def get_range(self, l, r):
"""
[l, r)への作用の結果を返す (0-indexed)
"""
l += self.size
r += self.size
self.propagate_lazy(l//(l&-l))
self.propagate_lazy((r//(r&-r))-1)
res_l = self.ef
res_r = self.ef
while l < r:
if l & 1:
res_l = self.f(res_l, self.g(self.lazy[l], self.tree[l]))
l += 1
if r & 1:
r -= 1
res_r = self.f(self.g(self.lazy[r], self.tree[r]), res_r)
l >>= 1
r >>= 1
return self.f(res_l, res_r)
def max_right(self, l, z):
"""
以下の条件を両方満たす r を(いずれか一つ)返す
・r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・r = n or f(op(a[l], a[l + 1], ..., a[r])) = false
"""
if l >= self.n: return self.n
l += self.size
s = self.ef
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
while l < self.size:
l *= 2
if z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
return l - self.size
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
if l & -l == l: break
return self.n
def min_left(self, r, z):
"""
以下の条件を両方満たす l を(いずれか一つ)返す
・l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・l = 0 or f(op(a[l - 1], a[l], ..., a[r - 1])) = false
"""
if r <= 0: return 0
r += self.size
s = self.ef
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
while r < self.size:
r = r * 2 + 1
if z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
r -= 1
return r + 1 - self.size
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
if r & -r == r: break
return 0
def propagate_lazy(self, i):
"""
lazy の値をトップダウンで更新する （ O(logN) ）
"""
for k in range(i.bit_length()-1,0,-1):
x = i>>k
if self.lazy[x] == self.eh:
continue
laz = self.lazy[x]
self.lazy[(x<<1)|1] = self.h(laz, self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(laz, self.lazy[x<<1])
self.tree[x] = self.g(laz, self.tree[x]) # get_range ではボトムアップの伝搬を行わないため、この処理をしないと tree が更新されない
self.lazy[x] = self.eh
def propagate_tree(self, i):
"""
tree の値をボトムアップで更新する （ O(logN) ）
"""
while i>1:
i>>=1
self.tree[i] = self.f(self.g(self.lazy[i<<1], self.tree[i<<1]), self.g(self.lazy[(i<<1)|1], self.tree[(i<<1)|1]))
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.eh:
continue
self.lazy[(x<<1)|1] = self.h(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(self.lazy[x], self.lazy[x<<1])
self.tree[x] = self.g(self.lazy[x], self.tree[x])
self.lazy[x] = self.eh
for xh, x in zip(self.lazy[self.size:self.size+self.n], self.tree[self.size:self.size+self.n]):
yield self.g(xh,x)
def __str__(self):
return str(list(self))
#########################################################################################################
from itertools import accumulate
import sys
input = sys.stdin.readline
MOD = 998244353
off = 22
mask = 1<<22
N, Q = list(map(int, input().split()))
P = [pow(10,p,MOD) for p in range(N+1)]
SP = [0]
for p in P:
SP.append((SP[-1]+p)%MOD)
# クエリ関数
ef = 0
def f(x, y):
x0, x1 = divmod(x,1<<off)
y0, y1 = divmod(y,1<<off)
res = x0*P[y1]+y0
res %= MOD
return (res<<off) + x1+y1
# merge関数
eh = -1
def h(a,b):
return a if a != eh else b
# 更新関数（g が局所的か要確認
def g(a, x):
x1 = x%mask
res = a*SP[x1]%MOD
return (res<<off) + x1
st = LazySegmentTree(N, f, g, h, ef, eh)
st.built([(1<<off) + 1]*N)
for _ in range(Q):
L, R, D = list(map(int, input().split()))
st.update_range(L-1, R, D)
print(((st.get_range(0,N)>>off)%MOD))
| class LazySegmentTree():
def __init__(self, n, f, g, h, ef, eh):
"""
:param n: 配列の要素数
:param f: 取得半群の元同士の積を定義
:param g: 更新半群の元 xh が配列上の実際の値にどのように作用するかを定義
:param h: 更新半群の元同士の積を定義 （更新半群の元を xh と表記）
:param x: 配列の各要素の値。treeの葉以外は xf(x1,x2,...)
"""
self.n = n
self.f = f
self.g = lambda xh, x: g(xh, x) if xh != eh else x
self.h = h
self.ef = ef
self.eh = eh
l = (self.n - 1).bit_length()
self.size = 1 << l
self.tree = [self.ef] * (self.size << 1)
self.lazy = [self.eh] * ((self.size << 1) + 1)
self.plt_cnt = 0
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.f(self.tree[i<<1], self.tree[(i<<1)|1])
def update(self, i, x):
"""
i 番目の要素を x に更新する
"""
i += self.size
self.propagate_lazy(i)
self.tree[i] = x
self.lazy[i] = self.eh
self.propagate_tree(i)
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate_lazy(i)
return self.g(self.lazy[i], self.tree[i])
def update_range(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
if l >= r:
return
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate_lazy(l0)
self.propagate_lazy(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.h(x, self.lazy[r])
if l&1:
self.lazy[l] = self.h(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
self.propagate_tree(l0)
self.propagate_tree(r0-1)
def get_range(self, l, r):
"""
[l, r)への作用の結果を返す (0-indexed)
"""
l += self.size
r += self.size
self.propagate_lazy(l//(l&-l))
self.propagate_lazy((r//(r&-r))-1)
res_l = self.ef
res_r = self.ef
while l < r:
if l & 1:
res_l = self.f(res_l, self.g(self.lazy[l], self.tree[l]))
l += 1
if r & 1:
r -= 1
res_r = self.f(self.g(self.lazy[r], self.tree[r]), res_r)
l >>= 1
r >>= 1
return self.f(res_l, res_r)
def max_right(self, l, z):
"""
以下の条件を両方満たす r を(いずれか一つ)返す
・r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・r = n or f(op(a[l], a[l + 1], ..., a[r])) = false
"""
if l >= self.n: return self.n
l += self.size
s = self.ef
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
while l < self.size:
l *= 2
if z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
return l - self.size
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
if l & -l == l: break
return self.n
def min_left(self, r, z):
"""
以下の条件を両方満たす l を(いずれか一つ)返す
・l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・l = 0 or f(op(a[l - 1], a[l], ..., a[r - 1])) = false
"""
if r <= 0: return 0
r += self.size
s = self.ef
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
while r < self.size:
r = r * 2 + 1
if z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
r -= 1
return r + 1 - self.size
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
if r & -r == r: break
return 0
def propagate_lazy(self, i):
"""
lazy の値をトップダウンで更新する （ O(logN) ）
"""
for k in range(i.bit_length()-1,0,-1):
x = i>>k
if self.lazy[x] == self.eh:
continue
laz = self.lazy[x]
self.lazy[(x<<1)|1] = self.h(laz, self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(laz, self.lazy[x<<1])
self.tree[x] = self.g(laz, self.tree[x]) # get_range ではボトムアップの伝搬を行わないため、この処理をしないと tree が更新されない
self.lazy[x] = self.eh
def propagate_tree(self, i):
"""
tree の値をボトムアップで更新する （ O(logN) ）
"""
while i>1:
i>>=1
self.tree[i] = self.f(self.g(self.lazy[i<<1], self.tree[i<<1]), self.g(self.lazy[(i<<1)|1], self.tree[(i<<1)|1]))
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.eh:
continue
self.lazy[(x<<1)|1] = self.h(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(self.lazy[x], self.lazy[x<<1])
self.tree[x] = self.g(self.lazy[x], self.tree[x])
self.lazy[x] = self.eh
for xh, x in zip(self.lazy[self.size:self.size+self.n], self.tree[self.size:self.size+self.n]):
yield self.g(xh,x)
def __str__(self):
return str(list(self))
#########################################################################################################
from itertools import accumulate
import sys
input = sys.stdin.readline
MOD = 998244353
off = 22
mask = 1<<22
N, Q = list(map(int, input().split()))
P = [pow(10,p,MOD) for p in range(N+1)]
SP = [0]
for p in P:
SP.append((SP[-1]+p)%MOD)
# クエリ関数
ef = 0
def f(x, y):
x0, x1 = divmod(x,1<<off)
y0, y1 = divmod(y,1<<off)
res = x0*P[y1]+y0
res %= MOD
return (res<<off) + x1+y1
# merge関数
eh = -1
def h(a,b):
return a if a != eh else b
# 更新関数（g が局所的か要確認
def g(a, x):
x1 = x%mask
return a*(SP[x1]<<off) + x1
st = LazySegmentTree(N, f, g, h, ef, eh)
st.built([(1<<off) + 1]*N)
res = [""]*Q
for i in range(Q):
L, R, D = list(map(int, input().split()))
st.update_range(L-1, R, D)
res[i] = str((st.get_range(0,N)>>off)%MOD)
print(("\n".join(res)))
| p02538 |
class LazySegmentTree():
def __init__(self, n, f, g, h, ef, eh):
"""
:param n: 配列の要素数
:param f: 取得半群の元同士の積を定義
:param g: 更新半群の元 xh が配列上の実際の値にどのように作用するかを定義
:param h: 更新半群の元同士の積を定義 （更新半群の元を xh と表記）
:param x: 配列の各要素の値。treeの葉以外は xf(x1,x2,...)
"""
self.n = n
self.f = f
self.g = lambda xh, x: g(xh, x) if xh != eh else x
self.h = h
self.ef = ef
self.eh = eh
l = (self.n - 1).bit_length()
self.size = 1 << l
self.tree = [self.ef] * (self.size << 1)
self.lazy = [self.eh] * ((self.size << 1) + 1)
self.plt_cnt = 0
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.f(self.tree[i<<1], self.tree[(i<<1)|1])
def update(self, i, x):
"""
i 番目の要素を x に更新する
"""
i += self.size
self.propagate_lazy(i)
self.tree[i] = x
self.lazy[i] = self.eh
self.propagate_tree(i)
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate_lazy(i)
return self.g(self.lazy[i], self.tree[i])
def update_range(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
if l >= r:
return
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate_lazy(l0)
self.propagate_lazy(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.h(x, self.lazy[r])
if l&1:
self.lazy[l] = self.h(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
self.propagate_tree(l0)
self.propagate_tree(r0-1)
def get_range(self, l, r):
"""
[l, r)への作用の結果を返す (0-indexed)
"""
l += self.size
r += self.size
self.propagate_lazy(l//(l&-l))
self.propagate_lazy((r//(r&-r))-1)
res_l = self.ef
res_r = self.ef
while l < r:
if l & 1:
res_l = self.f(res_l, self.g(self.lazy[l], self.tree[l]))
l += 1
if r & 1:
r -= 1
res_r = self.f(self.g(self.lazy[r], self.tree[r]), res_r)
l >>= 1
r >>= 1
return self.f(res_l, res_r)
def max_right(self, l, z):
"""
以下の条件を両方満たす r を(いずれか一つ)返す
・r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・r = n or f(op(a[l], a[l + 1], ..., a[r])) = false
"""
if l >= self.n: return self.n
l += self.size
s = self.ef
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
while l < self.size:
l *= 2
if z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
return l - self.size
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
if l & -l == l: break
return self.n
def min_left(self, r, z):
"""
以下の条件を両方満たす l を(いずれか一つ)返す
・l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・l = 0 or f(op(a[l - 1], a[l], ..., a[r - 1])) = false
"""
if r <= 0: return 0
r += self.size
s = self.ef
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
while r < self.size:
r = r * 2 + 1
if z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
r -= 1
return r + 1 - self.size
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
if r & -r == r: break
return 0
def propagate_lazy(self, i):
"""
lazy の値をトップダウンで更新する （ O(logN) ）
"""
for k in range(i.bit_length()-1,0,-1):
x = i>>k
if self.lazy[x] == self.eh:
continue
laz = self.lazy[x]
self.lazy[(x<<1)|1] = self.h(laz, self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(laz, self.lazy[x<<1])
self.tree[x] = self.g(laz, self.tree[x]) # get_range ではボトムアップの伝搬を行わないため、この処理をしないと tree が更新されない
self.lazy[x] = self.eh
def propagate_tree(self, i):
"""
tree の値をボトムアップで更新する （ O(logN) ）
"""
while i>1:
i>>=1
self.tree[i] = self.f(self.g(self.lazy[i<<1], self.tree[i<<1]), self.g(self.lazy[(i<<1)|1], self.tree[(i<<1)|1]))
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.eh:
continue
self.lazy[(x<<1)|1] = self.h(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(self.lazy[x], self.lazy[x<<1])
self.tree[x] = self.g(self.lazy[x], self.tree[x])
self.lazy[x] = self.eh
for xh, x in zip(self.lazy[self.size:self.size+self.n], self.tree[self.size:self.size+self.n]):
yield self.g(xh,x)
def __str__(self):
return str(list(self))
#########################################################################################################
from itertools import accumulate
import sys
input = sys.stdin.readline
MOD = 998244353
off = 10**10
N, Q = list(map(int, input().split()))
P = [pow(10,p,MOD) for p in range(N+1)]
SP = [0]
for p in P:
SP.append((SP[-1]+p)%MOD)
# クエリ関数
ef = 0
def f(x, y):
x0, x1 = divmod(x,off)
y0, y1 = divmod(y,off)
res = x0*P[y1]+y0
res %= MOD
return (res*off) + x1+y1
# merge関数
eh = -1
def h(a,b):
return a if a != eh else b
# 更新関数（g が局所的か要確認
def g(a, x):
x0, x1 = divmod(x,off)
return a*SP[x1]%MOD*off + x1
st = LazySegmentTree(N, f, g, h, ef, eh)
st.built([(off) + 1]*N)
for _ in range(Q):
L, R, D = list(map(int, input().split()))
st.update_range(L-1, R, D)
print(((st.get_range(0,N)//off)%MOD))
| class LazySegmentTree():
def __init__(self, n, f, g, h, ef, eh):
"""
:param n: 配列の要素数
:param f: 取得半群の元同士の積を定義
:param g: 更新半群の元 xh が配列上の実際の値にどのように作用するかを定義
:param h: 更新半群の元同士の積を定義 （更新半群の元を xh と表記）
:param x: 配列の各要素の値。treeの葉以外は xf(x1,x2,...)
"""
self.n = n
self.f = f
self.g = lambda xh, x: g(xh, x) if xh != eh else x
self.h = h
self.ef = ef
self.eh = eh
l = (self.n - 1).bit_length()
self.size = 1 << l
self.tree = [self.ef] * (self.size << 1)
self.lazy = [self.eh] * ((self.size << 1) + 1)
self.plt_cnt = 0
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.f(self.tree[i<<1], self.tree[(i<<1)|1])
def update(self, i, x):
"""
i 番目の要素を x に更新する
"""
i += self.size
self.propagate_lazy(i)
self.tree[i] = x
self.lazy[i] = self.eh
self.propagate_tree(i)
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate_lazy(i)
return self.g(self.lazy[i], self.tree[i])
def update_range(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
if l >= r:
return
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate_lazy(l0)
self.propagate_lazy(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.h(x, self.lazy[r])
if l&1:
self.lazy[l] = self.h(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
self.propagate_tree(l0)
self.propagate_tree(r0-1)
def get_range(self, l, r):
"""
[l, r)への作用の結果を返す (0-indexed)
"""
l += self.size
r += self.size
self.propagate_lazy(l//(l&-l))
self.propagate_lazy((r//(r&-r))-1)
res_l = self.ef
res_r = self.ef
while l < r:
if l & 1:
res_l = self.f(res_l, self.g(self.lazy[l], self.tree[l]))
l += 1
if r & 1:
r -= 1
res_r = self.f(self.g(self.lazy[r], self.tree[r]), res_r)
l >>= 1
r >>= 1
return self.f(res_l, res_r)
def max_right(self, l, z):
"""
以下の条件を両方満たす r を(いずれか一つ)返す
・r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・r = n or f(op(a[l], a[l + 1], ..., a[r])) = false
"""
if l >= self.n: return self.n
l += self.size
s = self.ef
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
while l < self.size:
l *= 2
if z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
return l - self.size
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
if l & -l == l: break
return self.n
def min_left(self, r, z):
"""
以下の条件を両方満たす l を(いずれか一つ)返す
・l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・l = 0 or f(op(a[l - 1], a[l], ..., a[r - 1])) = false
"""
if r <= 0: return 0
r += self.size
s = self.ef
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
while r < self.size:
r = r * 2 + 1
if z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
r -= 1
return r + 1 - self.size
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
if r & -r == r: break
return 0
def propagate_lazy(self, i):
"""
lazy の値をトップダウンで更新する （ O(logN) ）
"""
for k in range(i.bit_length()-1,0,-1):
x = i>>k
if self.lazy[x] == self.eh:
continue
laz = self.lazy[x]
self.lazy[(x<<1)|1] = self.h(laz, self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(laz, self.lazy[x<<1])
self.tree[x] = self.g(laz, self.tree[x]) # get_range ではボトムアップの伝搬を行わないため、この処理をしないと tree が更新されない
self.lazy[x] = self.eh
def propagate_tree(self, i):
"""
tree の値をボトムアップで更新する （ O(logN) ）
"""
while i>1:
i>>=1
self.tree[i] = self.f(self.g(self.lazy[i<<1], self.tree[i<<1]), self.g(self.lazy[(i<<1)|1], self.tree[(i<<1)|1]))
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.eh:
continue
self.lazy[(x<<1)|1] = self.h(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(self.lazy[x], self.lazy[x<<1])
self.tree[x] = self.g(self.lazy[x], self.tree[x])
self.lazy[x] = self.eh
for xh, x in zip(self.lazy[self.size:self.size+self.n], self.tree[self.size:self.size+self.n]):
yield self.g(xh,x)
def __str__(self):
return str(list(self))
#########################################################################################################
from itertools import accumulate
import sys
input = sys.stdin.readline
MOD = 998244353
off = 1<<22
N, Q = list(map(int, input().split()))
P = [pow(10,p,MOD) for p in range(N+1)]
SP = [0]
for p in P:
SP.append((SP[-1]+p)%MOD)
# クエリ関数
ef = 0
def f(x, y):
x0, x1 = divmod(x,off)
y0, y1 = divmod(y,off)
res = x0*P[y1]+y0
res %= MOD
return (res*off) + x1+y1
# merge関数
eh = -1
def h(a,b):
return a if a != eh else b
# 更新関数（g が局所的か要確認
def g(a, x):
x1 = x%off
res = a*SP[x1]%MOD
return (res*off) + x1
st = LazySegmentTree(N, f, g, h, ef, eh)
st.built([(off) + 1]*N)
res = [""]*Q
for i in range(Q):
L, R, D = list(map(int, input().split()))
st.update_range(L-1, R, D)
res[i] = str((st.get_range(0,N)//off)%MOD)
print(("\n".join(res)))
| p02538 |
class LazySegmentTree():
def __init__(self, n, f, g, h, ef, eh):
"""
:param n: 配列の要素数
:param f: 取得半群の元同士の積を定義
:param g: 更新半群の元 xh が配列上の実際の値にどのように作用するかを定義
:param h: 更新半群の元同士の積を定義 （更新半群の元を xh と表記）
:param x: 配列の各要素の値。treeの葉以外は xf(x1,x2,...)
"""
self.n = n
self.f = f
self.g = lambda xh, x: g(xh, x) if xh != eh else x
self.h = h
self.ef = ef
self.eh = eh
l = (self.n - 1).bit_length()
self.size = 1 << l
self.tree = [self.ef] * (self.size << 1)
self.lazy = [self.eh] * ((self.size << 1) + 1)
self.plt_cnt = 0
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.f(self.tree[i<<1], self.tree[(i<<1)|1])
def update(self, i, x):
"""
i 番目の要素を x に更新する
"""
i += self.size
self.propagate_lazy(i)
self.tree[i] = x
self.lazy[i] = self.eh
self.propagate_tree(i)
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate_lazy(i)
return self.g(self.lazy[i], self.tree[i])
def update_range(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
if l >= r:
return
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate_lazy(l0)
self.propagate_lazy(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.h(x, self.lazy[r])
if l&1:
self.lazy[l] = self.h(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
self.propagate_tree(l0)
self.propagate_tree(r0-1)
def get_range(self, l, r):
"""
[l, r)への作用の結果を返す (0-indexed)
"""
l += self.size
r += self.size
self.propagate_lazy(l//(l&-l))
self.propagate_lazy((r//(r&-r))-1)
res_l = self.ef
res_r = self.ef
while l < r:
if l & 1:
res_l = self.f(res_l, self.g(self.lazy[l], self.tree[l]))
l += 1
if r & 1:
r -= 1
res_r = self.f(self.g(self.lazy[r], self.tree[r]), res_r)
l >>= 1
r >>= 1
return self.f(res_l, res_r)
def max_right(self, l, z):
"""
以下の条件を両方満たす r を(いずれか一つ)返す
・r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・r = n or f(op(a[l], a[l + 1], ..., a[r])) = false
"""
if l >= self.n: return self.n
l += self.size
s = self.ef
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
while l < self.size:
l *= 2
if z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
return l - self.size
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
if l & -l == l: break
return self.n
def min_left(self, r, z):
"""
以下の条件を両方満たす l を(いずれか一つ)返す
・l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・l = 0 or f(op(a[l - 1], a[l], ..., a[r - 1])) = false
"""
if r <= 0: return 0
r += self.size
s = self.ef
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
while r < self.size:
r = r * 2 + 1
if z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
r -= 1
return r + 1 - self.size
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
if r & -r == r: break
return 0
def propagate_lazy(self, i):
"""
lazy の値をトップダウンで更新する （ O(logN) ）
"""
for k in range(i.bit_length()-1,0,-1):
x = i>>k
if self.lazy[x] == self.eh:
continue
laz = self.lazy[x]
self.lazy[(x<<1)|1] = self.h(laz, self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(laz, self.lazy[x<<1])
self.tree[x] = self.g(laz, self.tree[x]) # get_range ではボトムアップの伝搬を行わないため、この処理をしないと tree が更新されない
self.lazy[x] = self.eh
def propagate_tree(self, i):
"""
tree の値をボトムアップで更新する （ O(logN) ）
"""
while i>1:
i>>=1
self.tree[i] = self.f(self.g(self.lazy[i<<1], self.tree[i<<1]), self.g(self.lazy[(i<<1)|1], self.tree[(i<<1)|1]))
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.eh:
continue
self.lazy[(x<<1)|1] = self.h(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(self.lazy[x], self.lazy[x<<1])
self.tree[x] = self.g(self.lazy[x], self.tree[x])
self.lazy[x] = self.eh
for xh, x in zip(self.lazy[self.size:self.size+self.n], self.tree[self.size:self.size+self.n]):
yield self.g(xh,x)
def __str__(self):
return str(list(self))
#########################################################################################################
from itertools import accumulate
import sys
input = sys.stdin.readline
MOD = 998244353
off = 10**10
N, Q = list(map(int, input().split()))
P = [pow(10,p,MOD) for p in range(N+1)]
SP = [0]
for p in P:
SP.append((SP[-1]+p)%MOD)
# クエリ関数
ef = 0
def f(x, y):
x0, x1 = divmod(x,off)
y0, y1 = divmod(y,off)
res = x0*P[y1]+y0
res %= MOD
return (res*off) + x1+y1
# merge関数
eh = -1
def h(a,b):
return a if a != eh else b
# 更新関数（g が局所的か要確認
def g(a, x):
x1 = x%off
res = a*SP[x1]%MOD
return (res*off) + x1
st = LazySegmentTree(N, f, g, h, ef, eh)
st.built([(off) + 1]*N)
res = [""]*Q
for i in range(Q):
L, R, D = list(map(int, input().split()))
st.update_range(L-1, R, D)
res[i] = str((st.get_range(0,N)//off)%MOD)
print(("\n".join(res)))
| class LazySegmentTree():
def __init__(self, n, f, g, h, ef, eh):
"""
:param n: 配列の要素数
:param f: 取得半群の元同士の積を定義
:param g: 更新半群の元 xh が配列上の実際の値にどのように作用するかを定義
:param h: 更新半群の元同士の積を定義 （更新半群の元を xh と表記）
:param x: 配列の各要素の値。treeの葉以外は xf(x1,x2,...)
"""
self.n = n
self.f = f
self.g = lambda xh, x: g(xh, x) if xh != eh else x
self.h = h
self.ef = ef
self.eh = eh
l = (self.n - 1).bit_length()
self.size = 1 << l
self.tree = [self.ef] * (self.size << 1)
self.lazy = [self.eh] * ((self.size << 1) + 1)
self.plt_cnt = 0
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.tree[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.tree[i] = self.f(self.tree[i<<1], self.tree[(i<<1)|1])
def update(self, i, x):
"""
i 番目の要素を x に更新する
"""
i += self.size
self.propagate_lazy(i)
self.tree[i] = x
self.lazy[i] = self.eh
self.propagate_tree(i)
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate_lazy(i)
return self.g(self.lazy[i], self.tree[i])
def update_range(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
if l >= r:
return
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate_lazy(l0)
self.propagate_lazy(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.h(x, self.lazy[r])
if l&1:
self.lazy[l] = self.h(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
self.propagate_tree(l0)
self.propagate_tree(r0-1)
def get_range(self, l, r):
"""
[l, r)への作用の結果を返す (0-indexed)
"""
l += self.size
r += self.size
self.propagate_lazy(l//(l&-l))
self.propagate_lazy((r//(r&-r))-1)
res_l = self.ef
res_r = self.ef
while l < r:
if l & 1:
res_l = self.f(res_l, self.g(self.lazy[l], self.tree[l]))
l += 1
if r & 1:
r -= 1
res_r = self.f(self.g(self.lazy[r], self.tree[r]), res_r)
l >>= 1
r >>= 1
return self.f(res_l, res_r)
def max_right(self, l, z):
"""
以下の条件を両方満たす r を(いずれか一つ)返す
・r = l or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・r = n or f(op(a[l], a[l + 1], ..., a[r])) = false
"""
if l >= self.n: return self.n
l += self.size
s = self.ef
while 1:
while l % 2 == 0:
l >>= 1
if not z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
while l < self.size:
l *= 2
if z(self.f(s, self.g(self.lazy[l], self.tree[l]))):
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
return l - self.size
s = self.f(s, self.g(self.lazy[l], self.tree[l]))
l += 1
if l & -l == l: break
return self.n
def min_left(self, r, z):
"""
以下の条件を両方満たす l を(いずれか一つ)返す
・l = r or f(op(a[l], a[l + 1], ..., a[r - 1])) = true
・l = 0 or f(op(a[l - 1], a[l], ..., a[r - 1])) = false
"""
if r <= 0: return 0
r += self.size
s = self.ef
while 1:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
while r < self.size:
r = r * 2 + 1
if z(self.f(self.g(self.lazy[r], self.tree[r]), s)):
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
r -= 1
return r + 1 - self.size
s = self.f(self.g(self.lazy[r], self.tree[r]), s)
if r & -r == r: break
return 0
def propagate_lazy(self, i):
"""
lazy の値をトップダウンで更新する （ O(logN) ）
"""
for k in range(i.bit_length()-1,0,-1):
x = i>>k
if self.lazy[x] == self.eh:
continue
laz = self.lazy[x]
self.lazy[(x<<1)|1] = self.h(laz, self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(laz, self.lazy[x<<1])
self.tree[x] = self.g(laz, self.tree[x]) # get_range ではボトムアップの伝搬を行わないため、この処理をしないと tree が更新されない
self.lazy[x] = self.eh
def propagate_tree(self, i):
"""
tree の値をボトムアップで更新する （ O(logN) ）
"""
while i>1:
i>>=1
self.tree[i] = self.f(self.g(self.lazy[i<<1], self.tree[i<<1]), self.g(self.lazy[(i<<1)|1], self.tree[(i<<1)|1]))
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.eh:
continue
self.lazy[(x<<1)|1] = self.h(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.h(self.lazy[x], self.lazy[x<<1])
self.tree[x] = self.g(self.lazy[x], self.tree[x])
self.lazy[x] = self.eh
for xh, x in zip(self.lazy[self.size:self.size+self.n], self.tree[self.size:self.size+self.n]):
yield self.g(xh,x)
def __str__(self):
return str(list(self))
#########################################################################################################
from itertools import accumulate
import sys
input = sys.stdin.readline
MOD = 998244353
off = 10**7
N, Q = list(map(int, input().split()))
P = [pow(10,p,MOD) for p in range(N+1)]
SP = [0]
for p in P:
SP.append((SP[-1]+p)%MOD)
# クエリ関数
ef = 0
def f(x, y):
x0, x1 = divmod(x,off)
y0, y1 = divmod(y,off)
res = x0*P[y1]+y0
res %= MOD
return (res*off) + x1+y1
# merge関数
eh = -1
def h(a,b):
return a if a != eh else b
# 更新関数（g が局所的か要確認
def g(a, x):
x1 = x%off
res = a*SP[x1]%MOD
return (res*off) + x1
st = LazySegmentTree(N, f, g, h, ef, eh)
st.built([(off) + 1]*N)
res = [""]*Q
for i in range(Q):
L, R, D = list(map(int, input().split()))
st.update_range(L-1, R, D)
res[i] = str((st.get_range(0,N)//off)%MOD)
print(("\n".join(res)))
| p02538 |
class LazySegTree:
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n-1).bit_length()
self.size = 1 << self.log
self.data = [e]*(2*self.size)
self.lazy = [id]*(self.size)
def update(self, k):
self.data[k] = self.op(self.data[2*k],self.data[2*k+1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2*k, self.lazy[k])
self.all_apply(2*k+1, self.lazy[k])
self.lazy[k] = self.id
def build(self, lis):
for i, l in enumerate(lis,self.size):
self.data[i] = l
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.data[p] = x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self, p):
p += self.size
for i in range(1, self.log+1):
self.push(p >> i)
return self.data[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 = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log+1):
self.update(p >> i)
def range_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 l2 < r2:
if l2 & 1:
self.all_apply(l2, f)
l2 += 1
if r2 & 1:
r2 -= 1
self.all_apply(r2, f)
l2 >>= 1
r2 >>= 1
for i in range(1, self.log+1):
if ((l >> i) << i) != l:
self.update(l >> i)
if ((r >> i) << i) != r:
self.update((r-1) >> i)
def max_right(self, l, g):
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 l % 2 == 0:
l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l <<= 1
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l:
return self.n
def min_left(self, r, g):
if r == 0:
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 % 2:
r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2*r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r:
return 0
mod = 998244353
po32 = pow(2,32)
n,q = list(map(int,input().split()))
def op(x, y):
xv,xr = divmod(x,po32)
yv,yr = divmod(y,po32)
return ((xv+yv)%mod)*po32 + (xr+yr)%mod
def mapping(p, x):
xv,xr = divmod(x, po32)
if p == float("INF"):
return x
return (p*xr % mod)*po32+xr
def composition(p, q):
if p == float("INF"):
return q
return p
lis = [0]*n
ten = 1
for i in range(n-1,-1,-1):
lis[i] = ten%mod
ten = (ten*10) % mod
l = [i*po32+i for i in lis]
e = 0
id = float("INF")
lazyseg = LazySegTree(n, op, e, mapping, composition, id)
lazyseg.build(l)
for i in range(q):
l,r,d = list(map(int,input().split()))
lazyseg.range_apply(l-1,r,d)
print((lazyseg.all_prod()//po32)) | import sys
input = sys.stdin.readline
INF = 10**18
class LazySegTree:
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n-1).bit_length()
self.size = 1 << self.log
self.data = [e]*(2*self.size)
self.lazy = [id]*(self.size)
def update(self, k):
self.data[k] = self.op(self.data[2*k],self.data[2*k+1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2*k, self.lazy[k])
self.all_apply(2*k+1, self.lazy[k])
self.lazy[k] = self.id
def build(self, lis):
for i, l in enumerate(lis,self.size):
self.data[i] = l
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.data[p] = x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self, p):
p += self.size
for i in range(1, self.log+1):
self.push(p >> i)
return self.data[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 = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log+1):
self.update(p >> i)
def range_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 l2 < r2:
if l2 & 1:
self.all_apply(l2, f)
l2 += 1
if r2 & 1:
r2 -= 1
self.all_apply(r2, f)
l2 >>= 1
r2 >>= 1
for i in range(1, self.log+1):
if ((l >> i) << i) != l:
self.update(l >> i)
if ((r >> i) << i) != r:
self.update((r-1) >> i)
def max_right(self, l, g):
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 l % 2 == 0:
l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l <<= 1
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l:
return self.n
def min_left(self, r, g):
if r == 0:
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 % 2:
r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2*r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r:
return 0
mod = 998244353
po32 = pow(2,32)
n,q = list(map(int,input().split()))
def op(x, y):
xv,xr = divmod(x,po32)
yv,yr = divmod(y,po32)
return ((xv+yv)%mod)*po32 + (xr+yr)%mod
def mapping(p, x):
xv,xr = divmod(x, po32)
if p == INF:
return x
return (p*xr % mod)*po32+xr
def composition(p, q):
if p == INF:
return q
return p
lis = [0]*n
ten = 1
for i in range(n-1,-1,-1):
lis[i] = ten%mod
ten = (ten*10) % mod
l = [i*po32+i for i in lis]
e = 0
id = INF
lazyseg = LazySegTree(n, op, e, mapping, composition, id)
lazyseg.build(l)
for i in range(q):
l,r,d = list(map(int,input().split()))
lazyseg.range_apply(l-1,r,d)
print((lazyseg.all_prod()//po32)) | p02538 |
# 方針 https://betrue12.hateblo.jp/entry/2020/09/27/013719
# ライブラリ https://github.com/not522/ac-library-python/blob/master/atcoder/lazysegtree.py
import typing
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = self._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
def _ceil_pow2(self, n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
N,Q=list(map(int,input().split()))
mod = 998244353
A = [(pow(10,N-1-i,mod),)*2 for i in range(N)]
def op(x,y):
return (x[0]+y[0]) % mod, (x[1]+y[1]) % mod
e = 0,0
def mapping(f,x):
if f == id_: return x
return f*x[1]%mod,x[1]
def composition(f,g):
if f==id_: f,g = g,f
return f
id_ = -1
seg = LazySegTree(op,e,mapping,composition,id_,A)
for i in range(Q):
l,r,d = list(map(int,input().split()))
seg.apply(l-1,r,d)
print((seg.all_prod()[0])) | # 方針 https://betrue12.hateblo.jp/entry/2020/09/27/013719
# ライブラリ https://github.com/not522/ac-library-python/blob/master/atcoder/lazysegtree.py
import typing
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = self._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
def _ceil_pow2(self, n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
N,Q=list(map(int,input().split()))
mod = 998244353
A = [pow(10,N-1-i,mod)*(1<<32 | 1) for i in range(N)]
mask = (1<<32)-1
def op(x,y):
x1,x2 = x>>32,x&mask
y1,y2 = y>>32,y&mask
z1,z2 = (x1+y1) % mod, (x2+y2) % mod
return z1<<32 | z2
e = 0
def mapping(f,x):
if f == id_: return x
x1,x2 = x>>32,x&mask
z1,z2 = f*x2%mod,x2
return z1<<32 | z2
def composition(f,g):
if f==id_: f,g = g,f
return f
id_ = -1
seg = LazySegTree(op,e,mapping,composition,id_,A)
for i in range(Q):
l,r,d = list(map(int,input().split()))
seg.apply(l-1,r,d)
print((seg.all_prod()>>32)) | p02538 |
import types
_atcoder_code = """
# Python port of AtCoder Library.
__version__ = '0.0.1'
"""
atcoder = types.ModuleType('atcoder')
exec(_atcoder_code, atcoder.__dict__)
_atcoder__bit_code = """
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
"""
atcoder._bit = types.ModuleType('atcoder._bit')
exec(_atcoder__bit_code, atcoder._bit.__dict__)
_atcoder_lazysegtree_code = """
import typing
# import atcoder._bit
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = atcoder._bit._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
"""
atcoder.lazysegtree = types.ModuleType('atcoder.lazysegtree')
atcoder.lazysegtree.__dict__['atcoder'] = atcoder
atcoder.lazysegtree.__dict__['atcoder._bit'] = atcoder._bit
exec(_atcoder_lazysegtree_code, atcoder.lazysegtree.__dict__)
LazySegTree = atcoder.lazysegtree.LazySegTree
# from atcoder.lazysegtree import LazySegTree
keta_to_mint10 = [0]*300001
keta_to_mint = [0]*300001
MOD = 998244353
def modinv(a,m):
b, u, v = m, 1, 0
while b:
t = a//b
a -= t*b
a,b = b,a
u -= t * v
u,v = v,u
u %= m
return u
def main():
def op(a,b):
return (a[0]*keta_to_mint10[b[1]] + b[0])%MOD, a[1]+b[1]
e = 0,0
f_id = 0
id_ = f_id
def mapping(f,x):
if f == f_id:
return x
else:
return (keta_to_mint[x[1]]*f)%MOD, x[1]
def composition(f,g):
if f == f_id: return g
else: return f
n,q = list(map(int, input().split()))
a = [(1,1)]*n
keta_to_mint10[0] = 1
mod9 = modinv(9,MOD)
for i in range(1,200001):
keta_to_mint10[i] = (keta_to_mint10[i-1]*10)%MOD
keta_to_mint[i] = ((keta_to_mint10[i]-1)*mod9)%MOD
seg = LazySegTree(op, e, mapping, composition, id_, a)
for _ in range(q):
l,r,d = list(map(int, input().split()))
seg.apply(l-1,r,d)
ans = seg.all_prod()[0]
print(ans)
if __name__ == "__main__":
main() | import typing
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
keta_to_mint10 = [0]*300001
keta_to_mint = [0]*300001
MOD = 998244353
def modinv(a,m):
b, u, v = m, 1, 0
while b:
t = a//b
a -= t*b
a,b = b,a
u -= t * v
u,v = v,u
u %= m
return u
def main():
def op(a,b):
return (a[0]*keta_to_mint10[b[1]] + b[0])%MOD, a[1]+b[1]
e = 0,0
f_id = 0
id_ = f_id
def mapping(f,x):
if f == f_id:
return x
else:
return (keta_to_mint[x[1]]*f)%MOD, x[1]
def composition(f,g):
if f == f_id: return g
else: return f
n,q = list(map(int, input().split()))
a = [(1,1)]*n
keta_to_mint10[0] = 1
mod9 = modinv(9,MOD)
for i in range(1,200001):
keta_to_mint10[i] = (keta_to_mint10[i-1]*10)%MOD
keta_to_mint[i] = ((keta_to_mint10[i]-1)*mod9)%MOD
seg = LazySegTree(op, e, mapping, composition, id_, a)
for _ in range(q):
l,r,d = list(map(int, input().split()))
seg.apply(l-1,r,d)
ans = seg.all_prod()[0]
print(ans)
if __name__ == "__main__":
main() | p02538 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### 遅延評価セグメント木
class LazySegmentTree:
def __init__(self, n, a=None):
"""初期化
num : n以上の最小の2のべき乗
"""
num = 1
while num<=n:
num *= 2
self.num = num
self.seg = [ninf] * (2*self.num-1)
self.lazy = [f0] * (2*self.num-1)
self.ls = [0]*(2*self.num-1)
self.rs = [0]*(2*self.num-1)
self.ls[0] = 0
self.rs[0] = self.num
for i in range(self.num-1):
self.ls[2*i+1] = self.ls[i]
self.rs[2*i+1] = (self.ls[i] + self.rs[i])//2
self.ls[2*i+2] = (self.ls[i] + self.rs[i])//2
self.rs[2*i+2] = self.rs[i]
if a is not None:
# O(n)で初期化
assert len(a)==n
for i in range(n):
self.seg[num-1+i] = a[i]
for k in range(num-2, -1, -1):
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def eval(self, k):
if self.lazy[k]==f0:
return
if k<self.num-1:
self.lazy[k*2+1] = composition(self.lazy[k], self.lazy[k*2+1])
self.lazy[k*2+2] = composition(self.lazy[k], self.lazy[k*2+2])
self.seg[k] = mapping(self.lazy[k], self.seg[k])
self.lazy[k] = f0
def eval_all(self):
for i in range(2*self.num-1):
self.eval(i)
def update(self,a,b,x=None,f=None):
"""A[a]...A[b-1]をxに更新する
"""
if f is None:
# 更新クエリ
f = lambda y: x
k = 0
q = [k] # k>=0なら行きがけ順
# 重なる区間を深さ優先探索
while q:
k = q.pop()
l,r = self.ls[k], self.rs[k]
if k>=0:
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
self.lazy[k] = composition(f, self.lazy[k])
self.eval(k)
else:
q.append(~k)
q.append(2*k+1)
q.append(2*k+2)
else:
k = ~k
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def query(self,a,b):
k = 0
l = 0
r = self.num
q = [k]
ans = ninf
# 重なる区間を深さ優先探索
while q:
k = q.pop()
l,r = self.ls[k], self.rs[k]
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
ans = op(ans, self.seg[k])
else:
q.append(2*k+2)
q.append(2*k+1)
# print(q, ans, l,r,a,b, self.seg[k])
return ans
n,q = list(map(int, input().split()))
M = 998244353
vals = [1]
vals2 = [1]
v = 1
for i in range(n):
v *= 10
v %= M
vals.append(v)
vals2.append((1+vals2[-1]*10)%M)
ninf = 0 # (転倒数, #0, #1)
V = (1<<32)
def op(x,y):
# print(x,bin(y))
return ((x%V)*vals[y//V] + y%V)%M + (x//V + y//V)*V
# op = lambda x,y: ((x[0]*vals[y[1]] + y[0])%M, x[1]+y[1])
# op = lambda x,y: ((x[0]*vals[y[1]] + y[0])%M, x[1]+y[1])
mapping = lambda f,x: x if f is None else ((f%10)*vals2[(x//V)-1])%M + (x//V)*V
def composition(f1,f2):
if f1 is None:
return f2
elif f2 is None:
return f1
else:
if f1//10<f2//10:
return f2
else:
return f1
# composition = lambda f1, f2: f1 if f2 is None else
f0 = None
sg = LazySegmentTree(n, [1+(1<<32)]*n)
ans = [None]*q
for i in range(q):
l,r,d = list(map(int, input().split()))
l -= 1
r -= 1
# print(l,r,d)
sg.update(l,r+1,f=10*i+d)
ans[i] = sg.query(0,n+1)%V
write("\n".join(map(str, ans))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### 遅延評価セグメント木
class LazySegmentTree:
def __init__(self, n, a=None):
"""初期化
num : n以上の最小の2のべき乗
"""
num = 1
while num<=n:
num *= 2
self.num = num
self.seg = [ninf] * (2*self.num-1)
self.lazy = [f0] * (2*self.num-1)
self.ls = [0]*(2*self.num-1)
self.rs = [0]*(2*self.num-1)
self.ls[0] = 0
self.rs[0] = self.num
for i in range(self.num-1):
self.ls[2*i+1] = self.ls[i]
self.rs[2*i+1] = (self.ls[i] + self.rs[i])//2
self.ls[2*i+2] = (self.ls[i] + self.rs[i])//2
self.rs[2*i+2] = self.rs[i]
if a is not None:
# O(n)で初期化
assert len(a)==n
for i in range(n):
self.seg[num-1+i] = a[i]
for k in range(num-2, -1, -1):
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def eval(self, k):
if self.lazy[k]==f0:
return
if k<self.num-1:
self.lazy[k*2+1] = composition(self.lazy[k], self.lazy[k*2+1])
self.lazy[k*2+2] = composition(self.lazy[k], self.lazy[k*2+2])
self.seg[k] = mapping(self.lazy[k], self.seg[k])
self.lazy[k] = f0
def eval_all(self):
for i in range(2*self.num-1):
self.eval(i)
def update(self,a,b,x=None,f=None):
"""A[a]...A[b-1]をxに更新する
"""
if f is None:
# 更新クエリ
f = lambda y: x
k = 0
q = [k] # k>=0なら行きがけ順
# 重なる区間を深さ優先探索
while q:
k = q.pop()
l,r = self.ls[k], self.rs[k]
if k>=0:
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
self.lazy[k] = composition(f, self.lazy[k])
self.eval(k)
else:
q.append(~k)
q.append(2*k+1)
q.append(2*k+2)
else:
k = ~k
self.seg[k] = op(self.seg[2*k+1], self.seg[2*k+2])
def query(self,a,b):
k = 0
l = 0
r = self.num
q = [k]
ans = ninf
# 重なる区間を深さ優先探索
while q:
k = q.pop()
l,r = self.ls[k], self.rs[k]
self.eval(k)
if r<=a or b<=l:
continue
elif a<=l and r<=b:
ans = op(ans, self.seg[k])
else:
q.append(2*k+2)
q.append(2*k+1)
# print(q, ans, l,r,a,b, self.seg[k])
return ans
n,q = list(map(int, input().split()))
M = 998244353
vals = [1]
vals2 = [1]
v = 1
for i in range(n):
v *= 10
v %= M
vals.append(v)
vals2.append((1+vals2[-1]*10)%M)
ninf = 0 # (転倒数, #0, #1)
V = (1<<32)
def op(x,y):
# print(x,bin(y))
return ((x%V)*vals[y//V] + y%V)%M + (x//V + y//V)*V
# op = lambda x,y: ((x[0]*vals[y[1]] + y[0])%M, x[1]+y[1])
# op = lambda x,y: ((x[0]*vals[y[1]] + y[0])%M, x[1]+y[1])
mapping = lambda f,x: x if f is None else ((f%10)*vals2[(x//V)-1])%M + (x//V)*V
def composition(f1,f2):
if f1 is None:
return f2
else:
return f1
# elif f2 is None:
# return f1
# else:
# if f1//10<f2//10:
# return f2
# else:
# return f1
# composition = lambda f1, f2: f1 if f2 is None else
f0 = None
sg = LazySegmentTree(n, [1+(1<<32)]*n)
ans = [None]*q
for i in range(q):
l,r,d = list(map(int, input().split()))
l -= 1
r -= 1
# print(l,r,d)
sg.update(l,r+1,f=10*i+d)
ans[i] = sg.query(0,n+1)%V
write("\n".join(map(str, ans)))
| p02538 |
class lazy_segtree():
def __init__(self,V,OP,E,MAPPING,COMPOSITION,ID):
self.n=len(V)
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
self.lz=[ID for i in range(self.size)]
self.e=E
self.op=OP
self.mapping=MAPPING
self.composition=COMPOSITION
self.identity=ID
for i in range(self.n):self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
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 get(self,p):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
return self.d[p]
def prod(self,l,r):
assert 0<=l and l<=r and 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.d[l])
l+=1
if r&1:
r-=1
smr=self.op(self.d[r],smr)
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):return self.d[1]
def apply(self,p,f):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
self.d[p]=self.mapping(f,self.d[p])
for i in range(1,self.log+1):self.update(p>>i)
def apply(self,l,r,f):
assert 0<=l and l<=r and 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)
l2,r2=l,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,r=l2,r2
for i in range(1,self.log+1):
if (((l>>i)<<i)!=l):self.update(l>>i)
if (((r>>i)<<i)!=r):self.update((r-1)>>i)
def max_right(self,l,g):
assert 0<=l and 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(1):
while(i%2==0):l>>=1
if not(g(self.op(sm,self.d[l]))):
while(l<self.size):
self.push(l)
l=(2*l)
if (g(self.op(sm,self.d[l]))):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:break
return self.n
def min_left(self,r,g):
assert (0<=r and r<=self.n)
assert g(self.e)
if r==0:return 0
r+=self.size
for i in range(self.log,0,-1):self.push((r-1)>>i)
sm=self.e
while(1):
r-=1
while(r>1 and (r%2)):r>>=1
if not(g(self.op(self.d[r],sm))):
while(r<self.size):
self.push(r)
r=(2*r+1)
if g(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r&-r)==r:break
return 0
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.identity
import sys
input=sys.stdin.readline
N,Q=list(map(int,input().split()))
mod=998244353
inv9=pow(9,mod-2,mod)
def operate(a,b):
a0,a1=a>>32,a%(1<<32)
b0,b1=b>>32,b%(1<<32)
x0=(a0*pow(10,b1,mod)+b0)%mod
x1=a1+b1
return (x0<<32)+x1
def mapping(f,x):
f0,f1=f>>32,f%(1<<32)
x0,x1=x>>32,x%(1<<32)
y0=(f0*x0+f1*inv9*(pow(10,x1,mod)-1))%mod
y1=x1
return (y0<<32)+y1
def composition(f,g):
f0,f1=f>>32,f%(1<<32)
g0,g1=g>>32,g%(1<<32)
return (((f0*g0)%mod)<<32)+((g1*f0+f1)%mod)
G=lazy_segtree([(1<<32)+1 for i in range(N)],operate,0,mapping,composition,1<<32)
for i in range(Q):
l,r,d=list(map(int,input().split()))
l-=1
G.apply(l,r,d)
print((G.all_prod()>>32))
| class lazy_segtree():
def __init__(self,V,OP,E,MAPPING,COMPOSITION,ID):
self.n=len(V)
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
self.lz=[ID for i in range(self.size)]
self.e=E
self.op=OP
self.mapping=MAPPING
self.composition=COMPOSITION
self.identity=ID
for i in range(self.n):self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
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 get(self,p):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
return self.d[p]
def prod(self,l,r):
assert 0<=l and l<=r and 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.d[l])
l+=1
if r&1:
r-=1
smr=self.op(self.d[r],smr)
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):return self.d[1]
def apply(self,p,f):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
self.d[p]=self.mapping(f,self.d[p])
for i in range(1,self.log+1):self.update(p>>i)
def apply(self,l,r,f):
assert 0<=l and l<=r and 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)
l2,r2=l,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,r=l2,r2
for i in range(1,self.log+1):
if (((l>>i)<<i)!=l):self.update(l>>i)
if (((r>>i)<<i)!=r):self.update((r-1)>>i)
def max_right(self,l,g):
assert 0<=l and 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(1):
while(i%2==0):l>>=1
if not(g(self.op(sm,self.d[l]))):
while(l<self.size):
self.push(l)
l=(2*l)
if (g(self.op(sm,self.d[l]))):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:break
return self.n
def min_left(self,r,g):
assert (0<=r and r<=self.n)
assert g(self.e)
if r==0:return 0
r+=self.size
for i in range(self.log,0,-1):self.push((r-1)>>i)
sm=self.e
while(1):
r-=1
while(r>1 and (r%2)):r>>=1
if not(g(self.op(self.d[r],sm))):
while(r<self.size):
self.push(r)
r=(2*r+1)
if g(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r&-r)==r:break
return 0
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.identity
import sys
input=sys.stdin.readline
N,Q=list(map(int,input().split()))
mod=998244353
inv9=pow(9,mod-2,mod)
pow10=[0 for i in range(N+1)]
pow10[0]=1
for i in range(N):
pow10[i+1]=(10*pow10[i])%mod
def operate(a,b):
a0,a1=a>>32,a%(1<<32)
b0,b1=b>>32,b%(1<<32)
x0=(a0*pow10[b1]+b0)%mod
x1=a1+b1
return (x0<<32)+x1
def mapping(f,x):
f0,f1=f>>32,f%(1<<32)
x0,x1=x>>32,x%(1<<32)
y0=(f0*x0+f1*inv9*(pow10[x1]-1))%mod
y1=x1
return (y0<<32)+y1
def composition(f,g):
f0,f1=f>>32,f%(1<<32)
g0,g1=g>>32,g%(1<<32)
return (((f0*g0)%mod)<<32)+((g1*f0+f1)%mod)
G=lazy_segtree([(1<<32)+1 for i in range(N)],operate,0,mapping,composition,1<<32)
for i in range(Q):
l,r,d=list(map(int,input().split()))
l-=1
G.apply(l,r,d)
print((G.all_prod()>>32))
| p02538 |
import sys
sys.setrecursionlimit(10**7)
mod = 998244353
INF = float("inf")
class lazySegTree(object):
def __init__(self, N):
self.N = N
self.LV = (N-1).bit_length()
self.N0 = 2**self.LV
self.data = [0]*(2*self.N0) #桁の値を管理(lazy*size)
self.lazy = [0]*(2*self.N0) #桁の文字を管理
self.size = [1]*(2*self.N0) #桁の和を管理(10^n)(更新しない)
for i in range(self.N):
self.size[self.N0-1+i] = pow(10, self.N-i-1, mod)
for i in range(self.N0-2, -1, -1):
self.size[i] = (self.size[2*i+1] + self.size[2*i+2])%mod
# 遅延セグ木の初期化
def initialize(self):
for i in range(self.N):
self.data[self.N0-1+i] = pow(10, self.N-i-1, mod)
for i in range(self.N0-2, -1, -1):
self.data[i] = (self.data[2*i+1] + self.data[2*i+2])%mod
# 遅延伝播を行うindexを生成
def gindex(self, l, r):
L = l + self.N0
L >>= 1
R = r + self.N0
R >>= 1
if l & 1:
lc = 0
else:
lc = (L & -L).bit_length()
if r & 1:
rc = 0
else:
rc = (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):
v = self.lazy[i - 1]
if not v:
continue
self.lazy[2*i-1] = v
self.lazy[2*i] = v
self.data[2*i-1] = v * self.size[2*i-1]
self.data[2*i] = v * self.size[2*i]
self.lazy[i-1] = 0
def update(self, l, r, x):
*ids, = self.gindex(l, r+1)
self.propagates(*ids)
L = self.N0 + l
R = self.N0 + r + 1
while L < R:
if R & 1:
R -= 1
self.lazy[R-1] = x #桁の文字を更新
self.data[R-1] = x * self.size[R-1] #桁の値を更新
if L & 1:
self.lazy[L-1] = x
self.data[L-1] = x * self.size[L-1]
L += 1
L >>= 1
R >>= 1
for i in ids:
self.data[i-1] = (self.data[2*i-1] + self.data[2*i])%mod
# 区間[l, r]内のdataの和を求める
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 = (s + self.data[R-1])%mod
if L & 1:
s = (s + self.data[L-1])%mod
L += 1
L >>= 1
R >>= 1
s %= mod
return s
N, Q = list(map(int, input().split()))
lSeg = lazySegTree(N)
lSeg.initialize()
for i in range(Q):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
lSeg.update(L, R, D)
ans = lSeg.query(0, N-1)
print(ans) | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.buffer.readline
mod = 998244353
INF = float("inf")
class lazySegTree(object):
def __init__(self, N):
self.N = N
self.LV = (N-1).bit_length()
self.N0 = 2**self.LV
self.data = [0]*(2*self.N0) #桁の値を管理(lazy*size)
self.lazy = [0]*(2*self.N0) #桁の文字を管理
self.size = [1]*(2*self.N0) #桁の和を管理(10^n)(更新しない)
for i in range(self.N):
self.size[self.N0-1+i] = pow(10, self.N-i-1, mod)
for i in range(self.N0-2, -1, -1):
self.size[i] = (self.size[2*i+1] + self.size[2*i+2])%mod
# 遅延セグ木の初期化
def initialize(self):
for i in range(self.N):
self.data[self.N0-1+i] = pow(10, self.N-i-1, mod)
for i in range(self.N0-2, -1, -1):
self.data[i] = (self.data[2*i+1] + self.data[2*i+2])%mod
# 遅延伝播を行うindexを生成
def gindex(self, l, r):
L = l + self.N0
L >>= 1
R = r + self.N0
R >>= 1
if l & 1:
lc = 0
else:
lc = (L & -L).bit_length()
if r & 1:
rc = 0
else:
rc = (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):
v = self.lazy[i - 1]
if not v:
continue
self.lazy[2*i-1] = v
self.lazy[2*i] = v
self.data[2*i-1] = v * self.size[2*i-1]
self.data[2*i] = v * self.size[2*i]
self.lazy[i-1] = 0
def update(self, l, r, x):
*ids, = self.gindex(l, r+1)
self.propagates(*ids)
L = self.N0 + l
R = self.N0 + r + 1
while L < R:
if R & 1:
R -= 1
self.lazy[R-1] = x #桁の文字を更新
self.data[R-1] = x * self.size[R-1] #桁の値を更新
if L & 1:
self.lazy[L-1] = x
self.data[L-1] = x * self.size[L-1]
L += 1
L >>= 1
R >>= 1
for i in ids:
self.data[i-1] = (self.data[2*i-1] + self.data[2*i])%mod
# 区間[l, r]内のdataの和を求める
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 = (s + self.data[R-1])%mod
if L & 1:
s = (s + self.data[L-1])%mod
L += 1
L >>= 1
R >>= 1
return s
N, Q = list(map(int, input().split()))
lSeg = lazySegTree(N)
lSeg.initialize()
for i in range(Q):
L, R, D = list(map(int, input().split()))
L -= 1
R -= 1
lSeg.update(L, R, D)
ans = lSeg.query(0, N-1)
ans %= mod
print(ans) | p02538 |
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)
N, Q = list(map(int, input().split()))
mod = 998244353
base = [(1, 1)] * N
tens = [0] * (N+1)
tens[0] = 1
for i in range(1, N+1):
tens[i] = (tens[i-1] * 10) % mod
ones = [0] * (N+1)
ones[1] = 1
for i in range(2, N+1):
ones[i] = (ones[i-1] * 10 + 1) % mod
def op(l, r):
return [(l[0] * tens[r[1]] + r[0]) % mod, l[1] + r[1]]
def mapping(l, r):
if l == 0:
return r
return [(l * ones[r[1]]) % mod, r[1]]
def composition(l, r):
if l == 0:
return r
return l
seg = LazySegmentTree(base, [0, 0], op, 0, mapping, composition)
for i in range(Q):
L, R, D = list(map(int, input().split()))
seg.apply_range(L-1, R, D)
print((seg.prod_all()[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)
N, Q = list(map(int, input().split()))
MOD = 998244353
MASK = 1 << 32
base = [MASK + 1] * N
tens = [0] * (N+1)
tens[0] = 1
for i in range(1, N+1):
tens[i] = (tens[i-1] * 10) % MOD
ones = [0] * (N+1)
ones[1] = 1
for i in range(2, N+1):
ones[i] = (ones[i-1] * 10 + 1) % MOD
def op(l, r):
l0, l1 = l >> 32, l % MASK
r0, r1 = r >> 32, r % MASK
return (((l0 * tens[r1] + r0) % MOD) << 32) + (l1 + r1)
def mapping(l, r):
if l == 0:
return r
r0, r1 = r >> 32, r % MASK
return (((l * ones[r1]) % MOD) << 32) + r1
def composition(l, r):
if l == 0:
return r
return l
seg = LazySegmentTree(base, 0, op, 0, mapping, composition)
for i in range(Q):
L, R, D = list(map(int, input().split()))
seg.apply_range(L-1, R, D)
print((seg.prod_all() >> 32))
| p02538 |
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [(e,e)] * (2 * self.size)
self.lazy = [id] * (self.size)
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size-1,0,-1):
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(self.log,0,-1):
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = list(map(int, input().split()))
def op(x, y):
xv, xr = x
yv, yr = y
return (xv + yv) % MOD, (xr + yr) % MOD
def mapping(p, x): #pが更新後の値, xが更新する前の値
xv, xr = x
if p != INF:
return p * xr % MOD, xr
return x
def composition(p, q):
if p != INF:
return p
return q
lis = [1] * (N)
for i in range(N-1,0,-1):
lis[i - 1] = lis[i] * 10 % MOD
arr = [(e,e) for e in lis]
e = 0
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(arr)
res = list()
for _ in range(Q):
l, r, d = list(map(int, input().split()))
lst.range_apply(l - 1, r, d)
v = lst.all_prod()
res.append(v[0])
print(('\n'.join(map(str, res))))
| class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [(e,e)] * (2 * self.size)
self.lazy = [id] * (self.size)
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size-1,0,-1):
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(self.log,0,-1):
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = map(int, input().split())
def op(x, y):
xv, xr = x
yv, yr = y
return (xv + yv) % MOD, (xr + yr) % MOD
def mapping(p, x): #pが更新後の値, xが更新する前の値
xv, xr = x
if p != INF:
return p * xr % MOD, xr
return x
def composition(p, q):
if p != INF:
return p
return q
lis = [1] * (N)
for i in range(N-1,0,-1):
lis[i - 1] = lis[i] * 10 % MOD
arr = [(e,e) for e in lis]
e = 0
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(arr)
ans = [0]*Q
for i in range(Q):
l, r, d = map(int, input().split())
lst.range_apply(l - 1, r, d)
v = lst.all_prod()
ans[i] = v[0]
print(*ans, sep='\n')
| p02538 |
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [e] * (2 * self.size)
self.lazy = [id] * (self.size)
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k): # 親の遅延配列の値を子に反映させる
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size-1,0,-1):
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
#事前に関係のある遅延配列を全て反映させてしまう
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = x #値を更新する
#関係のある区間の値も更新する
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
#関係のある遅延配列を全て反映させる
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(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
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(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 max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = map(int, input().split())
def op(x, y):
xv, xr = x
yv, yr = y
return (xv + yv) % MOD, (xr + yr) % MOD
def mapping(p, x): #pが更新後の値, xが更新する前の値
xv, xr = x
if p != INF:
return p * xr % MOD, xr
return x
def composition(p, q):
if p != INF:
return p
return q
lis = [1] * (N)
for i in range(N-1,0,-1):
lis[i - 1] = lis[i] * 10 % MOD
arr = [(e,e) for e in lis]
e = (0,0)
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(arr)
ans = [0]*Q
for i in range(Q):
l, r, d = map(int, input().split())
lst.range_apply(l - 1, r, d)
v = lst.all_prod()
ans[i] = v[0]
print(*ans, sep='\n')
| class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [e] * (2 * self.size)
self.lazy = [id] * (self.size)
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k): # 親の遅延配列の値を子に反映させる
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size-1,0,-1):
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
#事前に関係のある遅延配列を全て反映させてしまう
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = x #値を更新する
#関係のある区間の値も更新する
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
#関係のある遅延配列を全て反映させる
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(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
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(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 max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(self.log, 0, -1):
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(self.log, 0, -1):
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = map(int, input().split())
def op(x, y):
xv, xr = x
yv, yr = y
return (xv + yv) % MOD, (xr + yr) % MOD
def mapping(p, x): #pが更新後の値, xが更新する前の値
xv, xr = x
if p != INF:
return p * xr % MOD, xr
return x
def composition(p, q):
if p != INF:
return p
return q
lis = [1] * (N)
for i in range(N-1,0,-1):
lis[i - 1] = lis[i] * 10 % MOD
arr = [(e,e) for e in lis]
e = (0,0)
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(arr)
ans = [0]*Q
for i in range(Q):
l, r, d = map(int, input().split())
lst.range_apply(l - 1, r, d)
v = lst.all_prod()
ans[i] = v[0]
print(*ans, sep='\n')
| p02538 |
import sys
input = sys.stdin.readline
N,Q=list(map(int,input().split()))
mod=998244353
seg_el=1<<(N.bit_length()) # Segment treeの台の要素数
seg_height=1+N.bit_length() # Segment treeの高さ
SEG=[0 for i in range(2*seg_el)] # 区間の和
LAZY=[0 for i in range(2*seg_el)]
POW10=[pow(10,i,mod) for i in range(N+1)]
gyaku=pow(9,mod-2,mod)
def seg_function(x,y):
return (x+y)%mod
for i in range(N): # Aを対応する箇所へupdate
SEG[i+seg_el]=POW10[i]
for i in range(seg_el-1,0,-1): # 親の部分もupdate
SEG[i]=seg_function(SEG[i*2],SEG[i*2+1])
def lazy_change(ind,b):
kousuu = 1<< (seg_height - (ind.bit_length()))
tyousei = (ind - (1<<((ind.bit_length())-1)))*kousuu
#print(ind,tyousei,kousuu)
SEG[ind] = POW10[tyousei] * b * (POW10[kousuu]-1) * gyaku %mod
def lazy_compose(ind,b):
LAZY[ind]=b
def indexes(L,R): # 遅延伝搬すべきノードのリストを下から上の順に返す. （つまり, updateやgetvaluesで見るノードより上にあるノードたち）
INDLIST=[]
R-=1
L>>=1
R>>=1
while L!=R:
if L>R:
INDLIST.append(L)
L>>=1
else:
INDLIST.append(R)
R>>=1
while L!=0:
INDLIST.append(L)
L>>=1
return INDLIST
def changes(l,r,b0): # 区間[l,r)更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=0:
b=LAZY[ind]
lazy_change(ind<<1,b)
lazy_change(1+(ind<<1),b)
lazy_compose(ind<<1,b)
lazy_compose(1+(ind<<1),b)
LAZY[ind]=0
#print(SEG)
while L!=R:
if L > R:
lazy_change(L,b0)
lazy_compose(L,b0)
L+=1
L//=(L & (-L))
else:
R-=1
lazy_change(R,b0)
lazy_compose(R,b0)
R//=(R & (-R))
for ind in UPIND:
SEG[ind]=seg_function(SEG[ind<<1],SEG[1+(ind<<1)])
def getvalues(l,r):
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=0:
b=LAZY[ind]
lazy_change(ind<<1,b)
lazy_change(1+(ind<<1),b)
lazy_compose(ind<<1,b)
lazy_compose(1+(ind<<1),b)
LAZY[ind]=0
ANSL=0
ANSR=0
while L!=R:
if L > R:
ANSL=seg_function(ANSL,SEG[L])
L+=1
L//=(L & (-L))
else:
R-=1
ANSR=seg_function(SEG[R],ANSR)
R//=(R & (-R))
return seg_function(ANSL,ANSR)
for qu in range(Q):
L,R,D=list(map(int,input().split()))
L,R=N-R+1,N-L+1
#print(SEG)
changes(L-1,R,D)
sys.stdout.write(str(SEG[1])+"\n")
| import sys
input = sys.stdin.readline
N,Q=list(map(int,input().split()))
mod=998244353
seg_el=1<<(N.bit_length()) # Segment treeの台の要素数
seg_height=1+N.bit_length() # Segment treeの高さ
SEG=[0 for i in range(2*seg_el)] # 区間の和
LAZY=[0 for i in range(2*seg_el)]
POW10=[1]
for i in range(N+1):
POW10.append(POW10[-1]*10%mod)
gyaku=pow(9,mod-2,mod)
def seg_function(x,y):
return (x+y)%mod
for i in range(N): # Aを対応する箇所へupdate
SEG[i+seg_el]=POW10[i]
for i in range(seg_el-1,0,-1): # 親の部分もupdate
SEG[i]=seg_function(SEG[i*2],SEG[i*2+1])
def lazy_change(ind,b):
kousuu = 1<< (seg_height - (ind.bit_length()))
tyousei = (ind - (1<<((ind.bit_length())-1)))*kousuu
#print(ind,tyousei,kousuu)
SEG[ind] = POW10[tyousei] * b * (POW10[kousuu]-1) %mod * gyaku %mod
def lazy_compose(ind,b):
LAZY[ind]=b
def indexes(L,R): # 遅延伝搬すべきノードのリストを下から上の順に返す. （つまり, updateやgetvaluesで見るノードより上にあるノードたち）
INDLIST=[]
R-=1
L>>=1
R>>=1
while L!=R:
if L>R:
INDLIST.append(L)
L>>=1
else:
INDLIST.append(R)
R>>=1
while L!=0:
INDLIST.append(L)
L>>=1
return INDLIST
def changes(l,r,b0): # 区間[l,r)更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=0:
b=LAZY[ind]
lazy_change(ind<<1,b)
lazy_change(1+(ind<<1),b)
lazy_compose(ind<<1,b)
lazy_compose(1+(ind<<1),b)
LAZY[ind]=0
#print(SEG)
while L!=R:
if L > R:
lazy_change(L,b0)
lazy_compose(L,b0)
L+=1
L//=(L & (-L))
else:
R-=1
lazy_change(R,b0)
lazy_compose(R,b0)
R//=(R & (-R))
for ind in UPIND:
SEG[ind]=seg_function(SEG[ind<<1],SEG[1+(ind<<1)])
for qu in range(Q):
L,R,D=list(map(int,input().split()))
L,R=N-R+1,N-L+1
#print(SEG)
changes(L-1,R,D)
sys.stdout.write(str(SEG[1])+"\n")
| p02538 |
import typing
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
N,Q = list(map(int,input().split()))
D = [1,10]
E = [1,11]
a = 10
mod = 998244353
for i in range(N+1):
a*=10
a%=mod
D.append(a)
E.append((E[-1]+a)%mod)
def op(a,b):
return (b[0]+a[0]*D[b[1]])%mod, a[1]+b[1]
e = (0,0)
def mapping(f,a):
if f is None:
return a[0],a[1]
if a[0]==0:
return 0,0
return (f*E[a[1]-1])%mod, a[1]
def composition(f,g):
if f is None:
return g
else:
return f
id = None
lst = LazySegTree(op, e, mapping, composition, id, [(1,1) for i in range(N)])
for i in range(Q):
l,r,d = list(map(int,input().split()))
l,r = l-1,r-1
lst.apply(l,r+1,d)
print((lst.all_prod()[0]))
| import typing
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
D = [1,10]
E = [1,11]
mod = 998244353
def op(a,b):
return (b[0]+a[0]*D[b[1]])%mod, a[1]+b[1]
e = (0,0)
def mapping(f,a):
if f is None:
return a[0],a[1]
if a[0]==0:
return 0,0
return (f*E[a[1]-1])%mod, a[1]
def composition(f,g):
if f is None:
return g
else:
return f
id = None
import sys
sys.setrecursionlimit(500000)
def input():
return sys.stdin.readline()[:-1]
def main():
N,Q = list(map(int,input().split()))
a = 10
for i in range(N+1):
a*=10
a%=mod
D.append(a)
E.append((E[-1]+a)%mod)
lst = LazySegTree(op, e, mapping, composition, id, [(1,1) for i in range(N)])
for i in range(Q):
l,r,d = list(map(int,input().split()))
l,r = l-1,r-1
lst.apply(l,r+1,d)
print((lst.all_prod()[0]))
if __name__ == '__main__':
main() | p02538 |
import typing
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
D = [1,10]
E = [1,11]
mod = 998244353
def op(a : (int, int),b : (int, int)) -> (int, int):
return (b[0]+a[0]*D[b[1]])%mod, a[1]+b[1]
e = (0,0)
def mapping(f,a :(int,int)) -> (int, int):
if f is None:
return a[0],a[1]
if a[0]==0:
return 0,0
return (f*E[a[1]-1])%mod, a[1]
def composition(f,g):
if f is None:
return g
else:
return f
id = None
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
N,Q = list(map(int,input().split()))
a = 10
for i in range(N+1):
a*=10
a%=mod
D.append(a)
E.append((E[-1]+a)%mod)
lst = LazySegTree(op, e, mapping, composition, id, [(1,1) for i in range(N)])
for i in range(Q):
l,r,d = list(map(int,input().split()))
l,r = l-1,r-1
lst.apply(l,r+1,d)
print((lst.all_prod()[0]))
if __name__ == '__main__':
main()
|
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class LazySegTree:
def __init__(
self,
op,
e,
mapping,
composition,
id_,
v):
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x) -> None:
assert 0 <= p < self._n
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 get(self, p: int):
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int):
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self):
return self._d[1]
def apply(self, left: int, right = None,
f = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
D = [1,10]
E = [1,11]
mod = 998244353
def op(a ,b):
return (b[0]+a[0]*D[b[1]])%mod, a[1]+b[1]
e = (0,0)
def mapping(f,a):
if f is None:
return a[0],a[1]
if a[0]==0:
return 0,0
return (f*E[a[1]-1])%mod, a[1]
def composition(f,g):
if f is None:
return g
else:
return f
id = None
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
N,Q = list(map(int,input().split()))
a = 10
for i in range(N+1):
a*=10
a%=mod
D.append(a)
E.append((E[-1]+a)%mod)
lst = LazySegTree(op, e, mapping, composition, id, [(1,1) for i in range(N)])
for i in range(Q):
l,r,d = list(map(int,input().split()))
l,r = l-1,r-1
lst.apply(l,r+1,d)
print((lst.all_prod()[0]))
if __name__ == '__main__':
main() | p02538 |
import sys
input = sys.stdin.buffer.readline
class LazySegmentTree:
def __init__(self, n, unitX, unitA, X_f, A_f, XA_map):
self.n = n
self.unitX = unitX
self.unitA = unitA
self.X_f = X_f # (X, X) -> X
self.A_f = A_f # (A, A) -> A
self.XA_map = XA_map # (X, A) -> X
self.X = [unitX] * (n + n)
self.A = [unitA] * (n + n)
def __getitem__(self, i):
i += self.n
self._propagate_above(i)
return self.X[i]
def __setitem__(self, i, x):
i += self.n
self._propagate_above(i)
self.X[i] = x
self._calc_above(i)
def build(self, array):
for i, val in enumerate(array, self.n):
self.X[i] = val
for i in range(self.n - 1, 0, -1):
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def _calc_above(self, i):
while i > 1:
i >>= 1
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def _propagate_above(self, i):
k = i >> 1
H = k.bit_length() - 1
for h in range(H, -1, -1):
i = k >> h
if self.A[i] == self.unitA:
continue
self.X[i << 1] = self.XA_map(self.X[i << 1], self.A[i])
self.X[i << 1 | 1] = self.XA_map(self.X[i << 1 | 1], self.A[i])
self.A[i << 1] = self.A_f(self.A[i << 1], self.A[i])
self.A[i << 1 | 1] = self.A_f(self.A[i << 1 | 1], self.A[i])
self.A[i] = self.unitA
def fold(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)
xl = self.unitX
xr = self.unitX
while l < r:
if l & 1:
xl = self.X_f(xl, self.X[l])
l += 1
if r & 1:
r -= 1
xr = self.X_f(self.X[r], xr)
l >>= 1
r >>= 1
return self.X_f(xl, xr)
def apply(self, i, a):
i += self.n
self._propagate_above(i)
self.X[i] = self.XA_map(self.X[i], a)
self.A[i] = self.A_f(self.A[i], a)
self._calc_above(i)
def apply_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.X[l] = self.XA_map(self.X[l], a)
self.A[l] = self.A_f(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.X[r] = self.XA_map(self.X[r], a)
self.A[r] = self.A_f(self.A[r], a)
l >>= 1
r >>= 1
self._calc_above(l0)
self._calc_above(r0)
n, q = map(int, input().split())
queries = [list(map(int, input().split())) for i in range(q)]
MOD = 998244353
unitX = (0, 0, 0)
pow_ = [1] * (n + 1)
for i in range(n):
pow_[i + 1] = (pow_[i] * 10) % MOD
digit = [[0] * (n + 1) for i in range(10)]
for i in range(n):
for val in range(10):
digit[val][i + 1] = (digit[val][i] + pow_[i] * val) % MOD
def X_f(x1, x2):
return (x1[0] * pow_[abs(x1[1] - x2[1])] + x2[0]) % MOD, x2[1], x1[2] + x2[2]
unitA = 100
A_f = lambda a1, a2: a1 if a2 == unitA else a2
def XA_map(x, a):
if a != unitA: return digit[a][x[2]] % MOD, x[1], x[2]
lst = LazySegmentTree(n, unitX, unitA, X_f, A_f, XA_map)
lst.build([(1, n - i - 1, 1) for i in range(n)])
# print([lst.fold(i, i + 1) for i in range(n)])
# print(lst.fold(0, n))
ans = []
for l, r, d in queries:
l -= 1
lst.apply_range(l, r, d)
# print([lst.fold(i, i + 1) for i in range(n)])
ans.append(lst.fold(0, n)[0])
print(*ans, sep="\n")
| import sys
input = sys.stdin.buffer.readline
class LazySegmentTree:
def __init__(self, n, unitX, unitA, X_f, A_f, XA_map):
self.n = n
self.unitX = unitX
self.unitA = unitA
self.X_f = X_f # (X, X) -> X
self.A_f = A_f # (A, A) -> A
self.XA_map = XA_map # (X, A) -> X
self.X = [unitX] * (self.n + self.n)
self.A = [unitA] * (self.n + self.n)
def __getitem__(self, i):
i += self.n
self._propagate_above(i)
return self.X[i]
def __setitem__(self, i, x):
i += self.n
self._propagate_above(i)
self.X[i] = x
self._calc_above(i)
def build(self, array):
for i, val in enumerate(array, self.n):
self.X[i] = val
for i in range(self.n - 1, 0, -1):
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def _calc_above(self, i):
while i > 1:
i >>= 1
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def _propagate_above(self, i):
k = i >> 1
H = k.bit_length() - 1
for h in range(H, -1, -1):
i = k >> h
if self.A[i] == self.unitA:
continue
self.X[i << 1] = self.XA_map(self.X[i << 1], self.A[i])
self.X[i << 1 | 1] = self.XA_map(self.X[i << 1 | 1], self.A[i])
self.A[i << 1] = self.A_f(self.A[i << 1], self.A[i])
self.A[i << 1 | 1] = self.A_f(self.A[i << 1 | 1], self.A[i])
self.A[i] = self.unitA
def fold(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)
xl = self.unitX
xr = self.unitX
while l < r:
if l & 1:
xl = self.X_f(xl, self.X[l])
l += 1
if r & 1:
r -= 1
xr = self.X_f(self.X[r], xr)
l >>= 1
r >>= 1
return self.X_f(xl, xr)
def apply(self, i, a):
i += self.n
self._propagate_above(i)
self.X[i] = self.XA_map(self.X[i], a)
self.A[i] = self.A_f(self.A[i], a)
self._calc_above(i)
def apply_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.X[l] = self.XA_map(self.X[l], a)
self.A[l] = self.A_f(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.X[r] = self.XA_map(self.X[r], a)
self.A[r] = self.A_f(self.A[r], a)
l >>= 1
r >>= 1
self._calc_above(l0)
self._calc_above(r0)
n, q = map(int, input().split())
queries = [list(map(int, input().split())) for i in range(q)]
MOD = 998244353
pow_ = [1] * (n + 1)
for i in range(n):
pow_[i + 1] = (pow_[i] * 10) % MOD
digit = [[0] * (n + 1) for i in range(10)]
for i in range(n):
for val in range(10):
digit[val][i + 1] = (digit[val][i] + pow_[i] * val) % MOD
unitX = (0, 0)
def X_f(x1, x2):
return ((x1[0] * pow_[x2[1]] + x2[0]) % MOD, x1[1] + x2[1])
unitA = -1
A_f = lambda a1, a2: a1 if a2 == unitA else a2
def XA_map(x, a):
if a != unitA: x = (digit[a][x[1]], x[1])
return x
lst = LazySegmentTree(n, unitX, unitA, X_f, A_f, XA_map)
lst.build([(1, 1) for i in range(n)])
ans = []
for l, r, d in queries:
l -= 1
lst.apply_range(l, r, d)
ans.append(lst.fold(0, n)[0])
print(*ans, sep="\n")
| p02538 |
N, Q, *LRD = [int(_) for _ in open(0).read().split()]
L, R, D = LRD[::3], LRD[1::3], LRD[2::3]
mod = 998244353
class LazySegmentTree:
__slots__ = ["n", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, monoid_data, monoid_identity, operator_identity,
func_monoid_monoid, func_monoid_operator,
func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
self.n = len(monoid_data)
self.data = monoid_data * 2
for i in range(self.n - 1, 0, -1):
self.data[i] = self.fmm(self.data[2 * i], self.data[2 * i + 1])
self.lazy = [self.oe] * (self.n * 2)
def replace(self, index, value):
index += self.n
# propagation
for shift in range(index.bit_length() - 1, 0, -1):
i = index >> shift
self.lazy[2 * i] = self.foo(self.lazy[2 * i], self.lazy[i])
self.lazy[2 * i + 1] = self.foo(self.lazy[2 * i + 1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm(
self.fmo(self.data[2 * i], self.lazy[2 * i]),
self.fmo(self.data[2 * i + 1], self.lazy[2 * i + 1]))
self.lazy[i] = self.oe
def effect(self, l, r, operator):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l // (l & -l)) // 2
r0 = (r // (r & -r) - 1) // 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2 * i] = self.foo(self.lazy[2 * i], self.lazy[i])
self.lazy[2 * i + 1] = self.foo(self.lazy[2 * i + 1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
for i in indices:
self.data[i] = self.fmm(
self.fmo(self.data[2 * i], self.lazy[2 * i]),
self.fmo(self.data[2 * i + 1], self.lazy[2 * i + 1]))
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l // (l & -l)) // 2
r0 = (r // (r & -r) - 1) // 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2 * i] = self.foo(self.lazy[2 * i], self.lazy[i])
self.lazy[2 * i + 1] = self.foo(self.lazy[2 * i + 1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded,
self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]),
right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
#RSQ and RUQ
array = [(pow(10, i, mod), pow(10, i, mod), 1) for i in range(N)][::-1]
f = lambda a, b: ((a[0] + b[0]) % mod, (a[1] + b[1]) % mod, a[2] + b[2])
g = lambda a, b: (b * a[1] % mod, a[1], a[2]) if b else a
h = lambda a, b: b if b else a
ti = (0, 0, 0)
ei = 0
lst = LazySegmentTree(array, ti, ei, f, g, h)
ans = []
for l, r, d in zip(L, R, D):
lst.effect(l - 1, r, d)
ans += [lst.folded(0, N)[0]]
print(('\n'.join(map(str, ans))))
| N, Q, *LRD = [int(_) for _ in open(0).read().split()]
L, R, D = LRD[::3], LRD[1::3], LRD[2::3]
mod = 998244353
class LazySegmentTree:
__slots__ = ["n", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, monoid_data, monoid_identity, operator_identity,
func_monoid_monoid, func_monoid_operator,
func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
self.n = len(monoid_data)
self.data = monoid_data * 2
for i in range(self.n - 1, 0, -1):
self.data[i] = self.fmm(self.data[2 * i], self.data[2 * i + 1])
self.lazy = [self.oe] * (self.n * 2)
def replace(self, index, value):
index += self.n
# propagation
for shift in range(index.bit_length() - 1, 0, -1):
i = index >> shift
self.lazy[2 * i] = self.foo(self.lazy[2 * i], self.lazy[i])
self.lazy[2 * i + 1] = self.foo(self.lazy[2 * i + 1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm(
self.fmo(self.data[2 * i], self.lazy[2 * i]),
self.fmo(self.data[2 * i + 1], self.lazy[2 * i + 1]))
self.lazy[i] = self.oe
def effect(self, l, r, operator):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l // (l & -l)) // 2
r0 = (r // (r & -r) - 1) // 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2 * i] = self.foo(self.lazy[2 * i], self.lazy[i])
self.lazy[2 * i + 1] = self.foo(self.lazy[2 * i + 1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
for i in indices:
self.data[i] = self.fmm(
self.fmo(self.data[2 * i], self.lazy[2 * i]),
self.fmo(self.data[2 * i + 1], self.lazy[2 * i + 1]))
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
# preparing indices
indices = []
l0 = (l // (l & -l)) // 2
r0 = (r // (r & -r) - 1) // 2
while r0 > l0:
indices.append(r0)
r0 //= 2
while l0 > r0:
indices.append(l0)
l0 //= 2
while l0 and l0 != r0:
indices.append(r0)
r0 //= 2
if l0 == r0:
break
indices.append(l0)
l0 //= 2
while r0:
indices.append(r0)
r0 //= 2
# propagation
for i in reversed(indices):
self.lazy[2 * i] = self.foo(self.lazy[2 * i], self.lazy[i])
self.lazy[2 * i + 1] = self.foo(self.lazy[2 * i + 1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded,
self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]),
right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
#RSQ and RUQ
array = [(pow(10, i, mod), pow(10, i, mod)) for i in range(N)][::-1]
f = lambda a, b: ((a[0] + b[0]) % mod, (a[1] + b[1]) % mod)
g = lambda a, b: (b * a[1] % mod, a[1]) if b else a
h = lambda a, b: b if b else a
ti = (0, 0)
ei = 0
lst = LazySegmentTree(array, ti, ei, f, g, h)
ans = []
for l, r, d in zip(L, R, D):
lst.effect(l - 1, r, d)
ans += [lst.folded(0, N)[0]]
print(('\n'.join(map(str, ans))))
| p02538 |
N, Q, *LRD = [int(_) for _ in open(0).read().split()]
L, R, D = LRD[::3], LRD[1::3], LRD[2::3]
mod = 998244353
class LazySegmentTree():
def __init__(self, array, f, g, h, ti, ei):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
T x T -> T
T is dat
g : func
binary operation of the monoid
T x E -> T
T is dat, E is laz
h : func
binary operation of the monoid
E x E -> T
E is laz
ti : T
identity element of T
ei : E
identity element of E
"""
self.f = f
self.g = g
self.h = h
self.ti = ti
self.ei = ei
self.height = height = len(array).bit_length()
self.n = n = 2**height
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
self.laz = [ei] * (2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def reflect(self, k):
dat = self.dat
ei = self.ei
laz = self.laz
g = self.g
return self.dat[k] if laz[k] is ei else g(dat[k], laz[k])
def evaluate(self, k):
laz = self.laz
ei = self.ei
reflect = self.reflect
dat = self.dat
h = self.h
if laz[k] is ei:
return
laz[(k << 1) | 0] = h(laz[(k << 1) | 0], laz[k])
laz[(k << 1) | 1] = h(laz[(k << 1) | 1], laz[k])
dat[k] = reflect(k)
laz[k] = ei
def thrust(self, k):
height = self.height
evaluate = self.evaluate
for i in range(height, 0, -1):
evaluate(k >> i)
def recalc(self, k):
dat = self.dat
reflect = self.reflect
f = self.f
while k:
k >>= 1
dat[k] = f(reflect((k << 1) | 0), reflect((k << 1) | 1))
def update(self, a, b, x): # set value at position [a, b) (0-indexed)
thrust = self.thrust
n = self.n
h = self.h
laz = self.laz
recalc = self.recalc
a += n
b += n - 1
l = a
r = b + 1
thrust(a)
thrust(b)
while l < r:
if l & 1:
laz[l] = h(laz[l], x)
l += 1
if r & 1:
r -= 1
laz[r] = h(laz[r], x)
l >>= 1
r >>= 1
recalc(a)
recalc(b)
def set_val(self, a, x):
n = self.n
thrust = self.thrust
dat = self.dat
laz = self.laz
recalc = self.recalc
ei = self.ei
a += n
thrust(a)
dat[a] = x
laz[a] = ei
recalc(a)
def query(self, a, b): # result on interval [a, b) (0-indexed)
f = self.f
ti = self.ti
n = self.n
thrust = self.thrust
reflect = self.reflect
a += n
b += n - 1
thrust(a)
thrust(b)
l = a
r = b + 1
vl = vr = ti
while l < r:
if l & 1:
vl = f(vl, reflect(l))
l += 1
if r & 1:
r -= 1
vr = f(reflect(r), vr)
l >>= 1
r >>= 1
return f(vl, vr)
#RSQ and RUQ
array = [(pow(10, i, mod), pow(10, i, mod)) for i in range(N)][::-1]
f = lambda a, b: ((a[0] + b[0]) % mod, (a[1] + b[1]) % mod)
g = lambda a, b: (b * a[1] % mod, a[1])
h = lambda a, b: b
ti = (0, 0)
ei = -float('inf')
lst = LazySegmentTree(array=array, ti=ti, ei=ei, f=f, g=g, h=h)
ans = []
for l, r, d in zip(L, R, D):
lst.update(l - 1, r, d)
ans += [lst.query(0, N)[0]]
print(('\n'.join(map(str, ans))))
| N, Q, *LRD = [int(_) for _ in open(0).read().split()]
L, R, D = LRD[::3], LRD[1::3], LRD[2::3]
mod = 998244353
class LazySegmentTree():
def __init__(self, array, f, g, h, ti, ei):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
T x T -> T
T is dat
g : func
binary operation of the monoid
T x E -> T
T is dat, E is laz
h : func
binary operation of the monoid
E x E -> T
E is laz
ti : T
identity element of T
ei : E
identity element of E
"""
self.f = f
self.g = g
self.h = h
self.ti = ti
self.ei = ei
self.height = height = len(array).bit_length()
self.n = n = 2**height
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
self.laz = [ei] * (2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def reflect(self, k):
dat = self.dat
ei = self.ei
laz = self.laz
g = self.g
return self.dat[k] if laz[k] is ei else g(dat[k], laz[k])
def evaluate(self, k):
laz = self.laz
ei = self.ei
reflect = self.reflect
dat = self.dat
h = self.h
if laz[k] is ei:
return
laz[(k << 1) | 0] = h(laz[(k << 1) | 0], laz[k])
laz[(k << 1) | 1] = h(laz[(k << 1) | 1], laz[k])
dat[k] = reflect(k)
laz[k] = ei
def thrust(self, k):
height = self.height
evaluate = self.evaluate
for i in range(height, 0, -1):
evaluate(k >> i)
def recalc(self, k):
dat = self.dat
reflect = self.reflect
f = self.f
while k:
k >>= 1
dat[k] = f(reflect((k << 1) | 0), reflect((k << 1) | 1))
def update(self, a, b, x): # set value at position [a, b) (0-indexed)
thrust = self.thrust
n = self.n
h = self.h
laz = self.laz
recalc = self.recalc
a += n
b += n - 1
l = a
r = b + 1
thrust(a)
thrust(b)
while l < r:
if l & 1:
laz[l] = h(laz[l], x)
l += 1
if r & 1:
r -= 1
laz[r] = h(laz[r], x)
l >>= 1
r >>= 1
recalc(a)
recalc(b)
def set_val(self, a, x):
n = self.n
thrust = self.thrust
dat = self.dat
laz = self.laz
recalc = self.recalc
ei = self.ei
a += n
thrust(a)
dat[a] = x
laz[a] = ei
recalc(a)
def query(self, a, b): # result on interval [a, b) (0-indexed)
f = self.f
ti = self.ti
n = self.n
thrust = self.thrust
reflect = self.reflect
a += n
b += n - 1
thrust(a)
thrust(b)
l = a
r = b + 1
vl = vr = ti
while l < r:
if l & 1:
vl = f(vl, reflect(l))
l += 1
if r & 1:
r -= 1
vr = f(reflect(r), vr)
l >>= 1
r >>= 1
return f(vl, vr)
#RSQ and RUQ
array = [(pow(10, i, mod) * (2**30 + 1)) for i in range(N)][::-1]
def f(a, b):
qa, ra = divmod(a, 2**30)
qb, rb = divmod(b, 2**30)
return ((qa + qb) % mod) * 2**30 + (ra + rb) % mod
def g(a, b):
qa, ra = divmod(a, 2**30)
return ((ra * b) % mod) * 2**30 + ra
h = lambda a, b: b
ti = 0
ei = 0
lst = LazySegmentTree(array=array, ti=ti, ei=ei, f=f, g=g, h=h)
ans = []
for l, r, d in zip(L, R, D):
lst.update(l - 1, r, d)
ans += [lst.query(0, N) // 2**30]
print(('\n'.join(map(str, ans))))
| p02538 |
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import typing
import sys
def main(N, Q, LRD):
tree = LazySegTree(
op=lambda x, y: (x[0] * y[1] + y[0], x[1] * y[1]),
e=(Mint(0), Mint(1)),
mapping=lambda f, s: s if f == 0 else ((s[1] - 1) // 9 * f, s[1]),
composition=lambda f, g: g if f == 0 else f,
id_=0,
v=[(Mint(1), Mint(10))] * N)
for l, r, d in LRD:
l -= 1
tree.apply(l, r, d)
print((tree.all_prod()[0]))
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
MOD = 998244353
class Mint:
__slots__ = ('value')
def __init__(self, value=0):
self.value = value % MOD
if self.value < 0: self.value += MOD
@staticmethod
def get_value(x): return x.value if isinstance(x, Mint) else x
def inverse(self):
a, b = self.value, MOD
u, v = 1, 0
while b:
t = a // b
b, a = a - t * b, b
v, u = u - t * v, v
if u < 0: u += MOD
return u
def __repr__(self): return str(self.value)
def __eq__(self, other): return self.value == other.value
def __neg__(self): return Mint(-self.value)
def __hash__(self): return hash(self.value)
def __bool__(self): return self.value != 0
def __iadd__(self, other):
self.value = (self.value + Mint.get_value(other)) % MOD
return self
def __add__(self, other):
new_obj = Mint(self.value)
new_obj += other
return new_obj
__radd__ = __add__
def __isub__(self, other):
self.value = (self.value - Mint.get_value(other)) % MOD
if self.value < 0: self.value += MOD
return self
def __sub__(self, other):
new_obj = Mint(self.value)
new_obj -= other
return new_obj
def __rsub__(self, other):
new_obj = Mint(Mint.get_value(other))
new_obj -= self
return new_obj
def __imul__(self, other):
self.value = self.value * Mint.get_value(other) % MOD
return self
def __mul__(self, other):
new_obj = Mint(self.value)
new_obj *= other
return new_obj
__rmul__ = __mul__
def __ifloordiv__(self, other):
other = other if isinstance(other, Mint) else Mint(other)
self *= other.inverse()
return self
def __floordiv__(self, other):
new_obj = Mint(self.value)
new_obj //= other
return new_obj
def __rfloordiv__(self, other):
new_obj = Mint(Mint.get_value(other))
new_obj //= self
return new_obj
if __name__ == '__main__':
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
LRD = [tuple(map(int, input().split())) for _ in range(Q)]
main(N, Q, LRD)
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import typing
import sys
MOD = 998244353
def main(N, Q, LRD):
inv9 = pow(9, MOD - 2, MOD)
tree = LazySegTree(
op=lambda x, y: (((x[0] * y[1]) % MOD + y[0]) % MOD, (x[1] * y[1]) % MOD),
e=(0, 1),
mapping=lambda f, s: s if f == 0 else (((s[1] - 1) * inv9 * f) % MOD, s[1]),
composition=lambda f, g: g if f == 0 else f,
id_=0,
v=[(1, 10)] * N)
for l, r, d in LRD:
l -= 1
tree.apply(l, r, d)
print((tree.all_prod()[0]))
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
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 get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
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: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
if __name__ == '__main__':
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
LRD = [tuple(map(int, input().split())) for _ in range(Q)]
main(N, Q, LRD)
| p02538 |
mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.buffer.readline
def op(a, b, seg_len):
return (a * pow(10, seg_len, mod) + b)%mod
e = 0
inv9 = pow(9, mod - 2, mod)
def mapping(a, x, seg_len):
return ((x * inv9)%mod * (pow(10, seg_len, mod) - 1))%mod
def composition(x, y):
return y
id = -1
class LazySegTree:
# Range update query
def __init__(self, A, op=op, e=e, mapping=mapping, composition=composition, id=id, initialize=True):
self.N = len(A)
self.LV = (self.N - 1).bit_length()
self.N0 = 1 << self.LV
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
if initialize:
self.data = [self.e] * self.N0 + A + [self.e] * (self.N0 - self.N)
seg_len = 1
beki = self.N0 // 2
for i in range(self.N0 - 1, 0, -1):
self.data[i] = op(self.data[i * 2], self.data[i * 2 + 1], seg_len)
if i == beki:
seg_len <<= 1
beki >>= 1
else:
self.data = [self.e] * (self.N0 * 2)
self.lazy = [id] * (self.N0 * 2)
def _ascend(self, i, seg_len):
for _ in range(i.bit_length() - 1):
i >>= 1
self.data[i] = self.op(self.data[i * 2], self.data[i * 2 + 1], seg_len)
seg_len <<= 1
def _descend(self, idx):
lv = idx.bit_length()
seg_len = 1 << self.LV
for j in range(lv - 1, 0, -1):
seg_len >>= 1
i = idx >> j
x = self.lazy[i]
if x == self.id:
continue
self.lazy[i * 2] = self.composition(self.lazy[i * 2], x)
self.lazy[i * 2 + 1] = self.composition(self.lazy[i * 2 + 1], x)
self.lazy[i] = self.id
self.data[i * 2] = self.mapping(self.data[i * 2], x, seg_len)
self.data[i * 2 + 1] = self.mapping(self.data[i * 2 + 1], x, seg_len)
# open interval [l, r)
def apply(self, l, r, x):
l += self.N0 - 1
r += self.N0 - 1
self._descend(l // (l & -l))
self._descend(r // (r & -r) - 1)
l_ori = l
r_ori = r
seg_len = 1
while l < r:
if l & 1:
self.data[l] = self.mapping(self.data[l], x, seg_len)
self.lazy[l] = self.composition(self.lazy[l], x)
l += 1
if r & 1:
r -= 1
self.data[r] = self.mapping(self.data[r], x, seg_len)
self.lazy[r] = self.composition(self.lazy[r], x)
l >>= 1
r >>= 1
seg_len <<= 1
self._ascend(l_ori // (l_ori & -l_ori), l_ori & -l_ori)
self._ascend(r_ori // (r_ori & -r_ori) - 1, r_ori & -r_ori)
# open interval [l, r)
def query(self, l, r):
l += self.N0 - 1
r += self.N0 - 1
self._descend(l // (l & -l))
self._descend(r // (r & -r) - 1)
ret_l = self.e
ret_r = self.e
seg_len = 1
while l < r:
if l & 1:
ret_l = self.op(ret_l, self.data[l], seg_len)
l += 1
if r & 1:
ret_r = self.op(self.data[r - 1], ret_r, seg_len)
r -= 1
l >>= 1
r >>= 1
seg_len <<= 1
return self.op(ret_l, ret_r, 1)
N, Q = map(int, input().split())
N0 = 1 << (N - 1).bit_length()
ST = LazySegTree([0] * (N0-N) + [1] * N)
inv10 = pow(10, mod-2, mod)
ans = [0] * Q
for q in range(Q):
l, r, d = map(int, input().split())
ST.apply(N0 - N + l, N0 - N + r + 1, d)
ans[q] = (ST.query(N0 - N + 1, N0+1) * inv10)%mod
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.buffer.readline
beki10 = [0] * ((1 << 19) + 1)
beki10[0] = 1
for i in range(20):
beki10[1 << i] = pow(10, (1 << i), mod)
def op(a, b, seg_len):
return (a * beki10[seg_len] + b)%mod
e = 0
inv9 = pow(9, mod - 2, mod)
def mapping(a, x, seg_len):
return ((x * inv9)%mod * (beki10[seg_len] - 1))%mod
def composition(x, y):
return y
id = -1
class LazySegTree:
# Range update query
def __init__(self, A, op=op, e=e, mapping=mapping, composition=composition, id=id, initialize=True):
self.N = len(A)
self.LV = (self.N - 1).bit_length()
self.N0 = 1 << self.LV
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
if initialize:
self.data = [self.e] * self.N0 + A + [self.e] * (self.N0 - self.N)
seg_len = 1
beki = self.N0 // 2
for i in range(self.N0 - 1, 0, -1):
self.data[i] = op(self.data[i * 2], self.data[i * 2 + 1], seg_len)
if i == beki:
seg_len <<= 1
beki >>= 1
else:
self.data = [self.e] * (self.N0 * 2)
self.lazy = [id] * (self.N0 * 2)
def _ascend(self, i, seg_len):
for _ in range(i.bit_length() - 1):
i >>= 1
self.data[i] = self.op(self.data[i * 2], self.data[i * 2 + 1], seg_len)
seg_len <<= 1
def _descend(self, idx):
lv = idx.bit_length()
seg_len = 1 << self.LV
for j in range(lv - 1, 0, -1):
seg_len >>= 1
i = idx >> j
x = self.lazy[i]
if x == self.id:
continue
self.lazy[i * 2] = self.composition(self.lazy[i * 2], x)
self.lazy[i * 2 + 1] = self.composition(self.lazy[i * 2 + 1], x)
self.lazy[i] = self.id
self.data[i * 2] = self.mapping(self.data[i * 2], x, seg_len)
self.data[i * 2 + 1] = self.mapping(self.data[i * 2 + 1], x, seg_len)
# open interval [l, r)
def apply(self, l, r, x):
l += self.N0 - 1
r += self.N0 - 1
self._descend(l // (l & -l))
self._descend(r // (r & -r) - 1)
l_ori = l
r_ori = r
seg_len = 1
while l < r:
if l & 1:
self.data[l] = self.mapping(self.data[l], x, seg_len)
self.lazy[l] = self.composition(self.lazy[l], x)
l += 1
if r & 1:
r -= 1
self.data[r] = self.mapping(self.data[r], x, seg_len)
self.lazy[r] = self.composition(self.lazy[r], x)
l >>= 1
r >>= 1
seg_len <<= 1
self._ascend(l_ori // (l_ori & -l_ori), l_ori & -l_ori)
self._ascend(r_ori // (r_ori & -r_ori) - 1, r_ori & -r_ori)
# open interval [l, r)
def query(self, l, r):
l += self.N0 - 1
r += self.N0 - 1
self._descend(l // (l & -l))
self._descend(r // (r & -r) - 1)
ret_l = self.e
ret_r = self.e
seg_len = 1
while l < r:
if l & 1:
ret_l = self.op(ret_l, self.data[l], seg_len)
l += 1
if r & 1:
ret_r = self.op(self.data[r - 1], ret_r, seg_len)
r -= 1
l >>= 1
r >>= 1
seg_len <<= 1
return self.op(ret_l, ret_r, 1)
N, Q = map(int, input().split())
N0 = 1 << (N - 1).bit_length()
ST = LazySegTree([0] * (N0-N) + [1] * N)
inv10 = pow(10, mod-2, mod)
ans = [0] * Q
for q in range(Q):
l, r, d = map(int, input().split())
ST.apply(N0 - N + l, N0 - N + r + 1, d)
ans[q] = (ST.query(N0 - N + 1, N0+1) * inv10)%mod
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| p02538 |
MOD = 998244353
#####ide_ele#####
ide_ele = [0, 0]
#################
#####segfunc#####
def segfunc(x, y):
xa, xb = x
ya, yb = y
return [(xa + ya) % MOD, (xb + yb) % MOD]
#################
#####triv_act#####
triv_act = 0
#################
#####action#####
def action(x, p):
if p != triv_act:
_, xb = x
return [(xb * p) % MOD , xb]
return x
#################
class LazySegmentTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(l, r, x): 区間[l, r)をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele, action, triv_act):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
action: モノイドへの作用
ide_ele: 単位元
triv_act: モノイドへ自明に作用する元
num: n以上の最小の2のべき乗
data: 値配列(1-index)
lazy: 遅延配列(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.action = action
self.ide_ele = ide_ele
self.triv_act = triv_act
self.num = 1 << (n - 1).bit_length()
self.data = [ide_ele] * 2 * self.num
self.lazy = [triv_act] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.data[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def gindex(self, l, r):
"""
伝搬する対象の区間を求める
lm: 伝搬する必要のある最大の左閉区間
rm: 伝搬する必要のある最大の右開区間
"""
l += self.num
r += self.num
lm = (l // (l & -l)) >> 1
rm = (r // (r & -r)) >> 1
ids = []
while r > l > 0:
if l <= lm:
ids.append(l)
if r <= rm:
ids.append(r)
r >>= 1
l >>= 1
while l > 0:
ids.append(l)
l >>= 1
return ids
def propagates(self, ids):
"""
遅延伝搬処理
ids: 伝搬する対象の区間
"""
for j in range(len(ids)-1, -1, -1):
i = ids[j]
v = self.lazy[i]
if v == triv_act:
continue
lg = self.data[2 * i][1].bit_length()-1
self.lazy[2 * i] = v
self.lazy[2 * i + 1] = v
self.data[2 * i] = action(self.data[2 * i], v)
self.data[2 * i + 1] = action(self.data[2 * i + 1], v)
self.lazy[i] = self.triv_act
def update(self, l, r, x):
"""
区間[l, r)の値をxに更新
l, r: index(0-index)
x: update value
"""
ids = self.gindex(l, r)
self.propagates(ids)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.data[l] = action(self.data[l], x)
l += 1
if r & 1:
self.lazy[r - 1] = x
self.data[r - 1] = action(self.data[r - 1], x)
r >>= 1
l >>= 1
for i in ids:
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
#*ids, = self.gindex(l, r)
self.propagates(self.gindex(l, r))
res_l = self.ide_ele
res_r = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res_l = self.segfunc(res_l, self.data[l])
l += 1
if r & 1:
res_r = self.segfunc(self.data[r - 1], res_r)
l >>= 1
r >>= 1
return self.segfunc(res_l, res_r)
import sys
input = sys.stdin.buffer.readline
N, Q = map(int,input().split()) #3*10**5+5, 10**5
init = [[1,1] for _ in range(N)]
tmp = 1
for i in range(N-2,-1,-1):
tmp = (tmp * 10) % MOD
init[i][0], init[i][1] = tmp, tmp
lst = LazySegmentTree(init, segfunc, ide_ele, action, triv_act)
#print(lst.data[1], lst.data)
ans = [0 for _ in range(Q)]
for i in range(Q):
L, R, D = map(int,input().split()) #i, N//2+1, i*4 % 9 + 1
L -= 1
R -= 1
lst.update(L, R+1, D)
#print(lst.data[1], lst.data)
ans[i] = lst.data[1][0]
print(*ans, sep="\n")
#print(lst.data)
| class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [(e,e)] * (2 * self.size)
self.lazy = [id] * (self.size)
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size-1,0,-1):
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(self.log,0,-1):
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
import sys
input = sys.stdin.buffer.readline
INF = 10**18
MOD = 998244353
N, Q = map(int, input().split())
def op(x, y):
xv, xr = x
yv, yr = y
return (xv + yv) % MOD, (xr + yr) % MOD
def mapping(p, x): #pが更新後の値, xが更新する前の値
xv, xr = x
if p != INF:
return p * xr % MOD, xr
return x
def composition(p, q):
if p != INF:
return p
return q
lis = [[1,1] for _ in range(N)]
tmp = 1
for i in range(N-2,-1,-1):
tmp *= 10
tmp %= MOD
lis[i][0], lis[i][1] = tmp, tmp
#print(lis)
#arr = [(e,e) for e in lis]
e = 0
id = INF
lst = LazySegmentTree(N, op, e, mapping, composition, id)
lst.build(lis)
ans = [0]*Q
for i in range(Q):
l, r, d = map(int, input().split())
lst.range_apply(l - 1, r, d)
ans[i] = lst.data[1][0]
print(*ans, sep='\n')
| p02538 |
import sys
input = sys.stdin.readline
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [e] * (2 * self.size)
self.lz = [id] * (self.size)
def update(self, k):
# print(self.d)
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size:
self.lz[k] = self.composition(f, self.lz[k])
def push(self, k):
self.all_apply(2 * k, self.lz[k])
self.all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.d[self.size + i] = a
for i in range(1, self.size)[::-1]:
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.d[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: return 0
mod = 998244353
N,Q = list(map(int,input().split()))
O = [1]*(N+1)
c=kk=1
for i in range(1, N+1):
O[i] = c%mod
kk=kk*10%mod
c=(c+kk)%mod
def op(x, y):
return ((pow(10, y[1], mod)*x[0] + y[0]) % mod, x[1]+y[1])
def mapping(p, x):
if p:
return (O[x[1]] * p % mod, x[1])
return x
def composition(p, q):
if p == 0: return q
return p
res = [(1, 1)]*N
LST = LazySegmentTree(N,op,(0, 0),mapping,composition,0)
LST.build(res)
for _ in range(Q):
l,r,D = list(map(int,input().split()))
LST.range_apply(l-1,r,D)
print((LST.all_prod()[0]))
| import sys
input = sys.stdin.readline
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.d = [e] * (2 * self.size)
self.lz = [id] * (self.size)
def update(self, k):
# print(self.d)
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size:
self.lz[k] = self.composition(f, self.lz[k])
def push(self, k):
self.all_apply(2 * k, self.lz[k])
self.all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
def build(self, arr):
#assert len(arr) == self.n
for i, a in enumerate(arr):
self.d[self.size + i] = a
for i in range(1, self.size)[::-1]:
self.update(i)
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.d[p]
def prod(self, l, r):
#assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def apply(self, p, f):
#assert 0 <= p < self.n
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
#assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
def max_right(self, l, g):
#assert 0 <= l <= self.n
#assert g(self.e)
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r, g):
#assert 0 <= r <= self.n
#assert g(self.e)
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: return 0
mod = 998244353
N,Q = list(map(int,input().split()))
O = [1]*(N+1)
P = [1]*(N+1)
c=kk=1
for i in range(1, N+1):
O[i] = c
kk=kk*10%mod
P[i] = kk
c=(c+kk)%mod
def op(x, y):
return ((P[y[1]]*x[0] + y[0]) % mod, x[1]+y[1])
def mapping(p, x):
if p:
return (O[x[1]] * p % mod, x[1])
return x
def composition(p, q):
if p == 0: return q
return p
res = [(1, 1)]*N
LST = LazySegmentTree(N,op,(0, 0),mapping,composition,0)
LST.build(res)
for _ in range(Q):
l,r,D = list(map(int,input().split()))
LST.range_apply(l-1,r,D)
print((LST.all_prod()[0]))
| p02538 |
def main():
k = eval(input())
n = [
1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51
]
print((n[int(k) - 1]))
main()
| def main():
X = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(eval(input()))
return X[K - 1]
print((main())) | p02741 |
def mi():return list(map(int,input().split()))
l=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k=int(eval(input()))
print((l[k-1]))
| l=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print((l[int(eval(input()))-1]))
| p02741 |
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int(eval(input()))
print((A[k - 1])) | print(([1,1,1,2,1,2,1,5,2,2,1,5,1,2,1,14,1,5,1,5,2,2,1,15,2,2,5,4,1,4,1,51][int(eval(input()))-1])) | p02741 |
l = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print((l[int(eval(input()))-1])) | #!/usr/bin/env python3
print(([0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51][int(eval(input()))])) | p02741 |
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int(eval(input()))
print((A[k-1])) | A=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(eval(input()))
print((A[K-1])) | p02741 |
print((ord(' 3 '[int(eval(input()))%14]))) | print((b' 3 '[int(eval(input()))%14])) | p02741 |
print((b' 3 '[int(eval(input()))%14])) | print(ord(' 3 '[eval(input())%14])) | p02741 |
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(eval(input()))
print((A[K-1])) | K = int(eval(input()))
a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print((a[K-1])) | p02741 |
def main():
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(eval(input()))
print((A[K-1]))
if __name__ == "__main__":
main() | def main():
num = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(eval(input()))
print((num[K-1]))
if __name__ == "__main__":
main() | p02741 |
n = int(eval(input()))
x = []
y = []
h = []
for i in range(n):
xi,yi,hi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
h.append(hi)
cxyl = []
for i in range(101):
for j in range(101):
cxyl.append((i,j))
cxy = set(cxyl)
hd = {}
hzero = []
for i in range(n):
for c in list(cxy):
H = abs(x[i]-c[0]) + abs(y[i]-c[1]) + h[i]
if h[i] == 0:
hzero.append((x[i],y[i]))
if 1 > H:
cxy.remove(c)
continue
else:
if c in hd:
if hd[c] != H:
cxy.remove(c)
continue
else:
hd[c] = H
for xy in hzero:
xi = xy[0]
yi = xy[1]
for c in list(cxy):
H = abs(xi-c[0]) + abs(yi-c[1])
if hd[c] - H > 0:
cxy.remove(c)
ret = cxy.pop()
print((str(ret[0]) + ' ' + str(ret[1]) + ' ' + str(hd[ret])))
| n = int(eval(input()))
x = []
y = []
h = []
for i in range(n):
xi,yi,hi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
h.append(hi)
cxyl = []
for i in range(101):
for j in range(101):
cxyl.append((i,j))
cxy = set(cxyl)
hd = {}
hzero = set([])
for i in range(n):
for c in list(cxy):
H = abs(x[i]-c[0]) + abs(y[i]-c[1]) + h[i]
if h[i] == 0:
hzero.add((x[i],y[i]))
if 1 > H:
cxy.remove(c)
continue
else:
if c in hd:
if hd[c] != H:
cxy.remove(c)
continue
else:
hd[c] = H
for xy in list(hzero):
xi = xy[0]
yi = xy[1]
for c in list(cxy):
H = abs(xi-c[0]) + abs(yi-c[1])
if hd[c] - H > 0:
cxy.remove(c)
ret = cxy.pop()
print((str(ret[0]) + ' ' + str(ret[1]) + ' ' + str(hd[ret])))
| p03240 |
# 2019-11-10 20:23:41(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n = int(sys.stdin.readline().rstrip())
info = [[int(x) for x in sys.stdin.readline().split()] for _ in range(n)]
# 基準を決める
for i in range(n):
if info[i][2] >= 1:
x0, y0, h0 = info[i][0], info[i][1], info[i][2]
break
# else: すべてのhは h = 0
for x in range(101):
for y in range(101):
H = h0 + abs(x - x0) + abs(y - y0)
for i in range(n): # 中心(x, y, H)が条件を満たしているか確認する
h = max(H - abs(x - info[i][0]) - abs(y - info[i][1]), 0)
if h != info[i][2]: # 本当に中心なら同じ値になるはず
break # そうでないならこれは正しくない
else: # 全ての座標に対して条件を満たしていたなら
res = [x, y, H]
break # 中心は一意に決まるので見つかったらそれ以上調べる必要ない
for i in range(3):
res[i] = str(res[i])
print((' '.join(res)))
if __name__ == "__main__":
main() | # 2019-11-10 20:23:41(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n = int(sys.stdin.readline().rstrip())
info = [[int(x) for x in sys.stdin.readline().split()] for _ in range(n)]
# 基準を決める
for i in range(n):
if info[i][2] >= 1:
x0, y0, h0 = info[i][0], info[i][1], info[i][2]
break
# else: すべてのhは h = 0
for x in range(101):
for y in range(101):
H = h0 + abs(x - x0) + abs(y - y0)
for i in range(n): # 中心(x, y, H)が条件を満たしているか確認する
h = max(H - abs(x - info[i][0]) - abs(y - info[i][1]), 0)
if h != info[i][2]: # 本当に中心なら同じ値になるはず
break # そうでないならこれは正しくない
else: # 全ての座標に対して条件を満たしていたなら
res = [x, y, H]
for i in range(3):
res[i] = str(res[i])
print((' '.join(res)))
sys.exit() # 中心は一意に決まるので見つかったらそれ以上調べる必要ない
if __name__ == "__main__":
main() | p03240 |
# 2019-11-10 20:23:41(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n = int(sys.stdin.readline().rstrip())
info = [[int(x) for x in sys.stdin.readline().split()] for _ in range(n)]
# 基準を決める
for i in range(n):
if info[i][2] >= 1:
x0, y0, h0 = info[i][0], info[i][1], info[i][2]
break
# else: すべてのhは h = 0
for x in range(101):
for y in range(101):
H = h0 + abs(x - x0) + abs(y - y0)
for i in range(n): # 中心(x, y, H)が条件を満たしているか確認する
h = max(H - abs(x - info[i][0]) - abs(y - info[i][1]), 0)
if h != info[i][2]: # 本当に中心なら同じ値になるはず
break # そうでないならこれは正しくない
else: # 全ての座標に対して条件を満たしていたなら
res = [x, y, H]
for i in range(3):
res[i] = str(res[i])
print((' '.join(res)))
sys.exit() # 中心は一意に決まるので見つかったらそれ以上調べる必要ない
if __name__ == "__main__":
main() | import sys
n, *xyh = map(int, sys.stdin.read().split())
xyh = list(zip(*[iter(xyh)] * 3))
def conflict(cx, cy, ch, x, y, h):
return h != max(ch - abs(x - cx) - abs(y - cy), 0)
def main():
for x, y, h in xyh:
if h >= 1:
xt, yt, ht = x, y, h
break
for cx in range(101):
for cy in range(101):
ch = ht + abs(cx - xt) + abs(cy - yt)
for x, y, h in xyh:
if conflict(cx, cy, ch, x, y, h):
break
else:
return cx, cy, ch
if __name__ == '__main__':
ans = main()
print(*ans, sep=' ')
| p03240 |
def main():
N = int(input())
xyh = [[int(i) for i in input().split()] for _ in range(N)]
sx, sy, sh = [(x, y, h) for x, y, h in xyh if h != 0][0]
for cx in range(101):
for cy in range(101):
H = sh + abs(sx - cx) + abs(sy - cy)
if all(max(H-abs(x - cx)-abs(y - cy), 0) == h for x, y, h in xyh):
return print(cx, cy, H)
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.buffer.readline
N = int(input())
XYH = [[int(i) for i in input().split()] for j in range(N)]
XYH.sort(reverse=True, key=lambda p: p[2])
for cy in range(101):
for cx in range(101):
ch = XYH[0][2] + abs(XYH[0][0] - cx) + abs(XYH[0][1] - cy)
for x, y, h in XYH[1:]:
if h != max(ch - abs(x - cx) - abs(y - cy), 0):
break
else:
if ch != 0:
return print(cx, cy, ch)
print(-1)
if __name__ == '__main__':
main()
| p03240 |
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
INF = 10**18
N=ri()
xyh=[]
for i in range(N):
xyh += [rl()]
xyh.sort(reverse=True, key=lambda x:x[2])
ans=[-1]*3
for x in range(101):
if ans[0] != -1:
break
for y in range(101):
if ans[0] != -1:
break
if xyh[0][2] == 0:
h_m = xyh[0][2]+abs(x-xyh[0][0])+abs(y-xyh[0][1])
for i in range(1,N):
rst = xyh[i][2]+abs(x-xyh[i][0])+abs(y-xyh[i][1])
if h_m > rst:
h_m = rst
if h_m == 0:
break
elif i==N-1:
ans = [x,y,h_m]
else:
h = xyh[0][2]+abs(x-xyh[0][0])+abs(y-xyh[0][1])
for i in range(1,N):
if xyh[i][2] != 0:
if h != xyh[i][2]+abs(x-xyh[i][0])+abs(y-xyh[i][1]):
break
elif xyh[i][2] == 0:
if h > xyh[i][2]+abs(x-xyh[i][0])+abs(y-xyh[i][1]):
break
if i == N-1:
ans = [x,y,h]
print("{} {} {}".format(ans[0],ans[1],ans[2]))
| ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
INF = 10**18
N=ri()
X=[0]*N
Y=[0]*N
H=[0]*N
for i in range(N):
X[i],Y[i],H[i]=rl()
xyh=list(zip(X,Y,H))
xyh.sort(reverse=True,key=lambda x:x[2])
X,Y,H = zip(*xyh)
ans=[-1]*3
for x in range(101):
if ans[0] != -1:
break
for y in range(101):
if ans[0] != -1:
break
rst = H[0]+abs(x-X[0])+abs(y-Y[0])
for i in range(1,N):
if H[i] != 0 and rst != H[i]+abs(x-X[i])+abs(y-Y[i]):
break
elif H[i] == 0 and rst > H[i]+abs(x-X[i])+abs(y-Y[i]):
break
if i == N-1:
ans = [x,y,rst]
print("{} {} {}".format(ans[0],ans[1],ans[2]))
| p03240 |
n = int(eval(input()))
P = [0] * n
for i in range(n):
P[i] = list(map(int, input().split()))
P = sorted(P, key=lambda x: x[2], reverse=True)
max_h = P[0][2]
P2 = set()
for i in range(101):
for j in range(101):
P2.add((i, j))
for hh in range(max_h+200, max_h-1, -1):
P3 = P2.copy()
for x, y, h in P:
for xx, yy in P3.copy():
dx = abs(xx - x)
dy = abs(yy - y)
th = max(hh-dx-dy, 0)
if th != h:
P3.remove((xx, yy))
if len(P3) == 1:
xx, yy = P3.pop()
print(('%d %d %d' % (xx, yy, hh)))
| import sys
n = int(eval(input()))
P = [0] * n
for i in range(n):
P[i] = list(map(int, input().split()))
P = sorted(P, key=lambda x: x[2], reverse=True)
max_h = P[0][2]
for hh in range(max_h+200, max_h-1, -1):
for cx in range(101):
for cy in range(101):
for x, y, h in P:
th = max(hh-abs(cx-x)-abs(cy-y),0)
if h == th:
continue
else:
break
else:
print(('%d %d %d' % (cx, cy, hh)))
sys.exit(0)
| p03240 |
import itertools
n = int(input())
x, y, h = [], [], []
for _ in range(n):
xi, yi, hi = map(int, input().split())
if hi != 0:
x.append(xi)
y.append(yi)
h.append(hi)
candidate_cx = list(range(min(x), max(x) + 1))
candidate_cy = list(range(min(y), max(y) + 1))
candidate_ch = list(range(max(h), max(max(x) - min(x), max(y) - min(y)) + max(h) + 1))
for cx, cy, ch in list(itertools.product(candidate_cx, candidate_cy, candidate_ch)):
adapted = True
for xi, yi, hi in zip(x, y, h):
if hi != ch - abs(xi - cx) - abs(yi - cy):
adapted = False
break
if adapted == False:
continue
print(cx, cy, ch, sep = ' ')
exit(0)
| import itertools
n = int(input())
x, y, h = [], [], []
for _ in range(n):
xi, yi, hi = map(int, input().split())
if hi != 0:
x.append(xi)
y.append(yi)
h.append(hi)
candidate_cx = list(range(min(x), max(x) + 1))
candidate_cy = list(range(min(y), max(y) + 1))
for cx, cy in list(itertools.product(candidate_cx, candidate_cy)):
adapted = True
ch = 0
for xi, yi, hi in zip(x, y, h):
ch = max(ch, hi + abs(xi - cx) + abs(yi - cy))
for xi, yi, hi in zip(x, y, h):
if hi != ch - abs(xi - cx) - abs(yi - cy):
adapted = False
break
if adapted == False:
continue
print(cx, cy, ch, sep = ' ')
exit(0)
| p03240 |
import itertools
n = int(input())
x, y, h = [], [], []
for _ in range(n):
xi, yi, hi = map(int, input().split())
if hi != 0:
x.append(xi)
y.append(yi)
h.append(hi)
candidate_cx = list(range(min(x), max(x) + 1))
candidate_cy = list(range(min(y), max(y) + 1))
for cx, cy in list(itertools.product(candidate_cx, candidate_cy)):
adapted = True
ch = 0
for xi, yi, hi in zip(x, y, h):
ch = max(ch, hi + abs(xi - cx) + abs(yi - cy))
for xi, yi, hi in zip(x, y, h):
if hi != ch - abs(xi - cx) - abs(yi - cy):
adapted = False
break
if adapted == False:
continue
print(cx, cy, ch, sep = ' ')
exit(0)
| import itertools
n = int(input())
x, y, h = [], [], []
for _ in range(n):
xi, yi, hi = map(int, input().split())
if hi != 0:
x.append(xi)
y.append(yi)
h.append(hi)
candidate_cx = list(range(min(x), max(x) + 1))
candidate_cy = list(range(min(y), max(y) + 1))
for cx, cy in list(itertools.product(candidate_cx, candidate_cy)):
adapted = True
ch = h[0] + abs(x[0] - cx) + abs(y[0] - cy)
for xi, yi, hi in zip(x, y, h):
if hi != ch - abs(xi - cx) - abs(yi - cy):
adapted = False
break
if adapted == False:
continue
print(cx, cy, ch, sep = ' ')
exit(0)
| p03240 |
N = int(eval(input()))
points = [None] * N
for i in range(0, N):
points[i] = list(map(int, input().split()))
h_max = max([h for x, y, h in points])
for H in range(h_max + 100, h_max - 1, -1):
for Cx in range(101):
for Cy in range(101):
ok = True
for X, Y, h1 in points:
h2 = max(H - abs(X - Cx) - abs(Y - Cy), 0)
if h1 != h2:
ok = False
break
if ok:
print(('{} {} {}'.format(Cx, Cy, H)))
exit()
| N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
h_max = max(h for x, y, h in points)
for H in range(h_max, h_max + 1000):
for Cx in range(101):
for Cy in range(101):
ok = True
for x, y, h in points:
h_calc = max(H - abs(x - Cx) - abs(y - Cy), 0)
if h != h_calc:
ok = False
break
if ok:
print(('{} {} {}'.format(Cx, Cy, H)))
exit()
| p03240 |
N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
h_max = max(h for x, y, h in points)
for H in range(h_max, h_max + 1000):
for Cx in range(101):
for Cy in range(101):
ok = True
for x, y, h in points:
h_calc = max(H - abs(x - Cx) - abs(y - Cy), 0)
if h != h_calc:
ok = False
break
if ok:
print(('{} {} {}'.format(Cx, Cy, H)))
exit()
| N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
points.sort(key=lambda x: x[2], reverse=True)
for Cx in range(101):
for Cy in range(101):
kouho = set()
for xi, yi, hi in points:
if len(kouho) > 1:
break # 頂点が一意でない
if hi > 0:
"""観測点の高さが1以上なら頂点高を予測"""
kouho.add(hi + abs(xi - Cx) + abs(yi - Cy))
else:
"""観測点の高さが0なら式を満たしているかチェック"""
if list(kouho)[0] - abs(xi - Cx) - abs(yi - Cy) > 0:
kouho = set()
break
if len(kouho) == 1:
print(('{} {} {}'.format(Cx, Cy, list(kouho)[0])))
exit()
| p03240 |
N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
points.sort(key=lambda x: x[2], reverse=True)
for Cx in range(101):
for Cy in range(101):
kouho = set()
for xi, yi, hi in points:
if len(kouho) > 1:
break # 頂点が一意でない
if hi > 0:
"""観測点の高さが1以上なら頂点高を予測"""
kouho.add(hi + abs(xi - Cx) + abs(yi - Cy))
else:
"""観測点の高さが0なら式を満たしているかチェック"""
if list(kouho)[0] - abs(xi - Cx) - abs(yi - Cy) > 0:
kouho = set()
break
if len(kouho) == 1:
print(('{} {} {}'.format(Cx, Cy, list(kouho)[0])))
exit()
| N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
points.sort(key=lambda x: x[2], reverse=True)
for Cx in range(101):
for Cy in range(101):
H = None
for xi, yi, hi in points:
dx = abs(xi - Cx)
dy = abs(yi - Cy)
if hi > 0:
"""観測点の高さが1以上なら頂点高を予測"""
H_calc = hi + dx + dy
if H is None:
H = H_calc
elif H != H_calc:
H = None
break # 頂点高が一意ではない場合はNG
else:
"""観測点の高さが0なら式を満たしているかチェック"""
if H > dx + dy:
H = None
break # 満たしていない場合はNG
if H:
print(('{} {} {}'.format(Cx, Cy, H)))
exit()
| p03240 |
N = int(eval(input()))
XYH = [list(map(int, input().split())) for _ in range(N)]
H_max = max([XYH[i][2] for i in range(N)])
ans = []
# 高さH,中心座標を(Cx, Cy)として総当たりで試す
for H in range(H_max - 200, H_max + 201):
for Cx in range(0, 101):
for Cy in range(0, 101):
count = 0
for X, Y, h in XYH:
if h == max(H - abs(X - Cx) - abs(Y - Cy), 0):
count += 1
else:
break
if count == N:
ans = [str(Cx), str(Cy), str(H)]
print((' '.join(ans)))
| N = int(eval(input()))
XYH = [list(map(int, input().split())) for _ in range(N)]
H_list= [XYH[i][2] for i in range(N)]
H_max = max(H_list)
H_min = min(H_list)
H_diff = H_max - H_min
ans = []
# 高さH,中心座標を(Cx, Cy)として総当たりで試す
for H in range(H_max - (200 - H_diff), H_max + (201 - H_diff)):
for Cx in range(0, 101):
for Cy in range(0, 101):
count = 0
for X, Y, h in XYH:
if h == max(H - abs(X - Cx) - abs(Y - Cy), 0):
count += 1
else:
break
if count == N:
ans = [str(Cx), str(Cy), str(H)]
print((' '.join(ans)))
| p03240 |
# coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
def solve():
for x in range(101):
for y in range(101):
for h in range(h_min, h_min + 201):
for i in range(N):
if D[i][0] != max(h - abs(D[i][1] - x) - abs(D[i][2] - y), 0):
break
else:
return x, y, h
if __name__ == '__main__':
N = int(eval(input()))
D = []
for i in range(N):
x, y, h = inpl()
D.append([h, x, y])
h_min = max(D)[0]
ans = solve()
print((' '.join(map(str, ans))))
| # coding:utf-8
INF = float('inf')
def inpl(): return list(map(int, input().split()))
def solve():
for cx in range(101):
for cy in range(101):
ch = D[0][0] + abs(D[0][1] - cx) + abs(D[0][2] - cy)
for h, x, y in D:
if h != max(ch - (abs(x - cx) + abs(y - cy)), 0):
break
else:
return cx, cy, ch
if __name__ == '__main__':
N = int(eval(input()))
D = []
for i in range(N):
x, y, h = inpl()
D.append([h, x, y])
D.sort()
D.reverse()
ans = solve()
print((' '.join(map(str, ans))))
| p03240 |
from math import *
from itertools import *
import sys
N = int(eval(input()))
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx, cy in product(list(range(101)), list(range(101))):
flag = 1
H = h + abs(cx - x) + abs(cy - y)
for input_list in all_input_list:
if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
flag = 0
break
if (flag == 1):
print(("%s %s %s" % (cx, cy, H)))
sys.exit(0) | from math import *
import sys
N = int(eval(input()))
all_input_list = [[int(j) for j in input().split()] for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
for cy in range(101):
flag = 1
H = h + abs(cx - x) + abs(cy - y)
for input_list in all_input_list:
if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
flag = 0
break
if (flag == 1):
print(("%s %s %s" % (cx, cy, H)))
sys.exit(0) | p03240 |
from math import *
import sys
N = int(eval(input()))
all_input_list = [[int(j) for j in input().split()] for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
for cy in range(101):
flag = 1
H = h + abs(cx - x) + abs(cy - y)
for input_list in all_input_list:
if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
flag = 0
break
if (flag == 1):
print(("%s %s %s" % (cx, cy, H)))
sys.exit(0) | from math import *
import sys
N = int(eval(input()))
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
for cy in range(101):
H = h + abs(cx - x) + abs(cy - y)
for input_list in all_input_list:
if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
break
else:
print(("%s %s %s" % (cx, cy, H)))
sys.exit(0) | p03240 |
from math import *
N = int(eval(input()))
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
for cy in range(101):
H = h + abs(cx - x) + abs(cy - y)
for input_list in all_input_list:
if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
break
else:
print(("%s %s %s" % (cx, cy, H)))
exit()
| from math import *
import sys
N = int(eval(input()))
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = sorted(all_input_list, key=lambda x: x[2])[-1]
for cx in range(101):
for cy in range(101):
H = h + abs(cx - x) + abs(cy - y)
for input_list in all_input_list:
if (input_list[2] != max(H - abs(cx - input_list[0]) - abs(cy - input_list[1]), 0)):
break
else:
print(("%s %s %s" % (cx, cy, H)))
sys.exit(0) | p03240 |
import sys
n = int(eval(input()))
xyh = []
for i in range(n):
xyh.append(list(map(int, input().split())))
for cx in range(0, 101):
for cy in range(0, 101):
for H in range(max(1, xyh[0][2] - 201),
max(2, xyh[0][2] + 201)):
is_valid = True
for i in range(n):
x, y, h = xyh[i]
if max(H - abs(x - cx) - abs(y - cy), 0) != h:
is_valid = False
break
if is_valid is True:
print(('{} {} {}'.format(cx, cy, H)))
sys.exit()
| import sys
n = int(eval(input()))
xyh = []
for i in range(n):
xyh.append(list(map(int, input().split())))
if xyh[-1][2] >= 1:
G = xyh[-1]
for cx in range(0, 101):
for cy in range(0, 101):
hs = []
x, y, h = G
H = h + abs(x - cx) + abs(y - cy)
H = max(H, 0)
invalid = False
for i in range(n):
x, y, h = xyh[i]
hh = H - abs(x - cx) - abs(y - cy)
hh = max(hh, 0)
if hh != h:
invalid = True
break
if invalid is False:
print(("{} {} {}".format(cx, cy, H)))
sys.exit()
| p03240 |
N = int(eval(input()))
Xs = [list(map(int, input().split(" "))) for _ in range(N)]
"""
input = ["2 3 5","2 1 5","1 2 5","3 2 5"]
input = ["0 0 100", "1 1 98"]
input = ["99 1 191", "100 1 192", "99 0 192"]
Xs = [list(map(int, x.split(" "))) for x in input]
"""
Xs.sort(key=lambda x:x[2], reverse=True)
def solv(Xs):
for x in range(101):
for y in range(101):
h= Xs[0][2]
Cx = Xs[0][0]
Cy = Xs[0][1]
H = h + abs(x - Cx) + abs(y - Cy)
for i in range(len(Xs)):
h = max(H - abs(x - Xs[i][0]) - abs(y - Xs[i][1]), 0)
if h != Xs[i][2]:
break
if i == len(Xs)-1:
print(("%d %d %d" % (x, y, H)))
exit(0)
solv(Xs)
| N = int(eval(input()))
Xs = [list(map(int, input().split(" "))) for _ in range(N)]
"""
input = ["2 3 5","2 1 5","1 2 5","3 2 5"]
input = ["0 0 100", "1 1 98"]
input = ["99 1 191", "100 1 192", "99 0 192"]
Xs = [list(map(int, x.split(" "))) for x in input]
"""
Xs.sort(key=lambda x:x[2], reverse=True)
def solv(Xs):
for x in range(101):
for y in range(101):
Cx, Cy, h = tuple(Xs[0])
H = h + abs(x - Cx) + abs(y - Cy)
for Cx, Cy, h in Xs:
if max(H - abs(x - Cx) - abs(y - Cy), 0) != h:
break
else:
return (x, y, H)
print(("%d %d %d" % solv(Xs)))
| p03240 |
N=int(eval(input()))
xyh=[list(map(int, input().split())) for _ in range(N)]
maxh = max([h for _,_,h in xyh])
def find(cx, cy, H):
for x,y,h in xyh:
if h != max(H-abs(x-cx)-abs(y-cy), 0):
return False
return True
def all():
for cx in range(101):
for cy in range(101):
for H in range(min(1, maxh-200), maxh+201):
if find(cx, cy, H):
print(("%d %d %d" % (cx, cy, H)))
return
print("NOT FOUND")
all()
| N=int(eval(input()))
xyh=sorted([list(map(int, input().split())) for _ in range(N)], key=lambda x: x[2], reverse=True)
def find(cx, cy, H):
for x,y,h in xyh:
if h != max(H-abs(x-cx)-abs(y-cy), 0):
return False
return True
def solve():
for cx in range(101):
for cy in range(101):
x,y,h = xyh[0]
H = h + abs(x-cx) + abs(y-cy)
if find(cx, cy, H):
return "%d %d %d" % (cx, cy, H)
raise Exception
print((solve()))
| p03240 |
def c_pyramid(N, Pos):
from itertools import product
# 中心座標を全探索
for cx, cy in product(list(range(101)), repeat=2):
# ピラミッドの高さを求める
for x, y, h in Pos:
if h > 0:
height = h + abs(cx - x) + abs(cy - y)
# ピラミッドの高さが得られた情報に適合するか調べる
for x, y, h in Pos:
if h != max((height - abs(cx - x) - abs(cy - y)), 0):
break
else:
ans = [cx, cy, height]
break
ans = '{0} {1} {2}'.format(*ans)
return ans
N = int(eval(input()))
Pos = [[int(i) for i in input().split()] for j in range(N)]
print((c_pyramid(N, Pos))) | def c_pyramid():
N = int(eval(input()))
Pos = [[int(i) for i in input().split()] for j in range(N)]
# 与えられた情報から頂点座標を一意に得られるので、h=0にならない
x, y, h = sorted(Pos, key=lambda x: x[2])[-1]
# 中心座標を全探索
for cx in range(101):
for cy in range(101):
# 頂点の高さ height を決めたとき、すべての座標の情報と一致するか？
height = h + abs(x - cx) + abs(y - cy) # 定義式から逆算
if all(h_i == max(height - abs(x_i - cx) - abs(y_i - cy), 0)
for x_i, y_i, h_i in Pos):
return '{} {} {}'.format(cx, cy, height) # すべて一致した。これが解
return None
print((c_pyramid())) | p03240 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
from copy import deepcopy
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, S):
def init():
return [[INF, []] for _ in range(N+1)]
dp = init()
dp[0] = [0, []]
for i in range(N):
tmp = deepcopy(dp)
if S[i] == '1':
continue
for j in range(1, M+1):
k = i + j
if k > N:
break
if S[k] == '1':
continue
if dp[i][0] + 1 < dp[k][0]:
c, s = dp[i]
s = s[:]
s.append(j)
tmp[k] = [c + 1, s]
elif dp[i][0] + 1 == dp[k][0]:
c, s = dp[i]
s1 = s[:]
s2 = dp[k][1]
for c1, c2 in zip(s1, s2):
if c1 > c2:
break
else:
tmp[k] = [c + 1, s1]
dp = tmp
if dp[N][0] == INF:
return -1
return ' '.join(map(str, dp[N][1]))
def main():
N, M = read_int_n()
S = read_str()
print(slv(N, M, S))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
import resource
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
from copy import deepcopy
sys.setrecursionlimit(1000000)
s, h = resource.getrlimit(resource.RLIMIT_STACK)
# resource.setrlimit(resource.RLIMIT_STACK, (h, h))
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, S):
def f(s, p):
if p == 0:
return s
elif p < 0:
return None
for i in range(M, 0, -1):
j = p - i
if j < 0 or j >= len(S):
continue
if S[j] == '1':
continue
s.append(i)
v = f(s, j)
if v:
return v
s.pop()
return None
m = 0
mm = 0
for c in S:
if c == '1':
mm += 1
m = max(mm, m)
else:
mm = 0
if m >= M:
return -1
ans = f([], N)
if ans:
return ' '.join(map(str, reversed(ans)))
return -1
def main():
N, M = read_int_n()
S = read_str()
print(slv(N, M, S))
if __name__ == '__main__':
main()
| p02852 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
_, m = list(map(int, input().split()))
traps = [v == '1' for v in input().strip()]
values = [None] * len(traps)
values[0] = -1
for i in range(len(values) - 1):
if values[i] is None:
continue
for j in range(i + m, i, -1):
if j >= len(values) or traps[j]:
continue
if values[j] is not None:
break
values[j] = i
if values[-1] is None:
print((-1))
return
index = len(values) - 1
route = []
while values[index] != -1:
route.append(index - values[index])
index = values[index]
print((' '.join(str(v) for v in route[::-1])))
if __name__ == '__main__':
main()
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
_, m = list(map(int, input().split()))
traps = [v == '1' for v in input().strip()]
values = [None] * len(traps)
values[0] = -1
for i in range(len(values) - 1):
if values[i] is None:
continue
for j in range(min(i + m, len(values) - 1), i, -1):
if j >= len(values) or traps[j]:
continue
if values[j] is not None:
break
values[j] = i
if values[-1] is None:
print((-1))
return
index = len(values) - 1
route = []
while values[index] != -1:
route.append(index - values[index])
index = values[index]
print((' '.join(str(v) for v in route[::-1])))
if __name__ == '__main__':
main()
| p02852 |
import sys
sys.setrecursionlimit(1000000000)
from itertools import count
from functools import lru_cache
from collections import defaultdict
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
def meg(f, ok, ng):
while abs(ok-ng)>1:
mid = (ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
#
def main():
N, M = mis()
S = input()
@lru_cache(maxsize=None)
def rec(n):
if n < 0 or S[n] == '1':
return None, INF
elif n == 0:
return None, 0
min_i = None
min_v = INF
for i in range(max(n-M, 0), n):
_, v = rec(i)
if min_v > v:
min_v = v
min_i = i
return min_i, min_v
flag, _ = rec(N)
if flag is None:
print(-1)
else:
ans = []
pos = N
while pos != 0:
prev_pos, _ = rec(pos)
ans.append(pos - prev_pos)
pos = prev_pos
ans.reverse()
print(*ans, sep=' ')
main()
| import sys
sys.setrecursionlimit(1000000000)
from itertools import count
from functools import lru_cache
from collections import defaultdict
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
def meg(f, ok, ng):
while abs(ok-ng)>1:
mid = (ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
#
def main():
N, M = mis()
S = input()
ans = []
r = N
l = max(r - M, 0)
while r > 0:
for i in range(l, r):
if S[i] == '0':
ans.append(r - i)
r = i
l = max(r - M, 0)
break
else:
print(-1)
return
ans.reverse()
print(*ans, sep=' ')
main()
| p02852 |
# -*- coding: utf-8 -*-
import sys
N,M=list(map(int, sys.stdin.readline().split()))
S=sys.stdin.readline().strip()
L=[] #答えの集合
for _ in range(N):
for m in range(M,0,-1):
if 0<=N-m and S[N-m]=="0":
L.append(m)
N-=m
break
else:
break
if N!=0:
print(-1)
else:
print(" ".join(map(str,L[::-1])))
| # -*- coding: utf-8 -*-
import sys
N,M=list(map(int, sys.stdin.readline().split()))
S=sys.stdin.readline().strip()
L=[] #答えの配列の逆順
for _ in range(N):
for m in range(M,0,-1):
if 0<=N-m and S[N-m]=="0":
L.append(m)
N-=m
break
else:
break
if N!=0:
print(-1)
else:
print(" ".join(map(str,L[::-1])))
| p02852 |
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
#import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**6)
input=lambda: sys.stdin.readline().rstrip()
show_flg=False
show_flg=True
n,m=LI()
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n,0)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
seg=[]
num=0 # num:n以上の最小の2のべき乗
ide_ele=0 # 単位元
def segfun():
return
def __init__(self,n,init_val,segfun=sum,ide=0):
self.ide_ele=ide
self.num =2**(n-1).bit_length()
self.seg=[self.ide_ele]*2*self.num
self.segfun=segfun
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1) :
self.seg[i]=segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
ans=inf
s=[int(i) for i in input()]
def dp(b,m): # N log (N)
N=len(b)-1
n=N+1
global seg
global num
sg=SegTree(n,inf,min,inf)
sg.update(0,0)
dp=[0]+[inf]*(N)
for i in range(N):
if b[i+1]==1:
continue
dp[i+1]=sg.query(max(i-m+1,0),i+1)+1
sg.update(i+1,dp[i+1])
#show(seg)
#show(dp)
return dp
dp1=dp(s,m)
step=dp1[n]
if step==inf:
print(-1)
exit()
dp2=dp(s[::-1],m)[::-1]
move=[0]
ans=[]
j=1
for i in range(step,0,-1): # N
while j<=n and dp2[j]!=i-1:
j+=1
move.append(j)
for i in range(len(move)-1):
ans.append(move[i+1]-move[i])
print(*ans)
| from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
#import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**6)
input=lambda: sys.stdin.readline().rstrip()
show_flg=False
#show_flg=True
n,m=LI()
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n,0)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
s=[int(i) for i in input()]
def dp(b,m): # N log (N)
N=len(b)-1
n=N+1
sg=SegTree(n,inf,min,inf)
sg.update(0,0)
dp=[0]+[inf]*(N)
for i in range(N):
if b[i+1]==1:
continue
dp[i+1]=sg.query(max(i-m+1,0),i+1)+1
sg.update(i+1,dp[i+1])
#show(seg)
show(sg)
return dp
dp1=dp(s,m)
step=dp1[n]
if step==inf:
print(-1)
exit()
dp2=dp(s[::-1],m)[::-1]
show(dp1,'dp1')
move=[0]
ans=[]
j=1
for i in range(step,0,-1): # N
while j<=n and dp2[j]!=i-1:
j+=1
move.append(j)
for i in range(len(move)-1):
ans.append(move[i+1]-move[i])
print(*ans)
| p02852 |
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:
a,b=inp;c=1
else:
a,b,c=inp
if index==1:a-=1;b-=1
aa=(a,c);bb=(b,c);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(n,base=2):
rt=[]
for tb in range(base**n):s=[tb//(base**bt)%base for bt in range(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
read=sys.stdin.buffer.read
readline=sys.stdin.buffer.readline
input=lambda: sys.stdin.readline().rstrip()
class Tree:
def __init__(self,inp_size=None,ls=None,init=True,index=0):
self.LCA_init_stat=False
self.ETtable=[]
if init:
if ls==None:
self.stdin(inp_size,index=index)
else:
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls,index=index)
return
def stdin(self,inp_size=None,index=1):
if inp_size==None:
self.size=int(input())
else:
self.size=inp_size
self.edges,_=GI(self.size,self.size-1,index=index)
return
def listin(self,ls,index=0):
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls,index=index)
return
def __str__(self):
return str(self.edges)
def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
q=deque()
q.append(x)
v=[-1]*self.size
v[x]=root_v
while q:
c=q.pop()
for nb,d in self.edges[c]:
if v[nb]==-1:
q.append(nb)
v[nb]=func(v[c],nb,d)
return v
def EulerTour(self,x):
q=deque()
q.append(x)
self.depth=[None]*self.size
self.depth[x]=0
self.ETtable=[]
self.ETdepth=[]
self.ETin=[-1]*self.size
self.ETout=[-1]*self.size
cnt=0
while q:
c=q.pop()
if c<0:
ce=~c
else:
ce=c
for nb,d in self.edges[ce]:
if self.depth[nb]==None:
q.append(~ce)
q.append(nb)
self.depth[nb]=self.depth[ce]+1
self.ETtable.append(ce)
self.ETdepth.append(self.depth[ce])
if self.ETin[ce]==-1:
self.ETin[ce]=cnt
else:
self.ETout[ce]=cnt
cnt+=1
return
def LCA_init(self,root):
self.EulerTour(root)
#self.st=SparseTable(self.ETdepth,init_func=min,init_idl=inf)
self.st=SegTree(self.size*2-1,self.ETdepth,function=min,ide=inf)
self.LCA_init_stat=True
return
def LCA(self,root,x,y):
if self.LCA_init_stat==False:
self.LCA_init(root)
xin,xout=self.ETin[x],self.ETout[x]
yin,yout=self.ETin[y],self.ETout[y]
a=min(xin,yin)
b=max(xout,yout,xin,yin)
id_of_min_dep_in_et=self.st.query_id(a,b+1)
return self.ETtable[id_of_min_dep_in_et]
class SparseTable: # O(N log N) for init, O(1) for query(l,r)
def __init__(self,ls,init_func=min,init_idl=float('inf')):
self.func=init_func
self.idl=init_idl
self.size=len(ls)
self.N0=self.size.bit_length()
self.table=[ls[:]]
self.index=[list(range(self.size))]
self.lg=[0]*(self.size+1)
for i in range(2,self.size+1):
self.lg[i]=self.lg[i>>1]+1
for i in range(self.N0):
tmp=[self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) for j in range(self.size)]
tmp_id=[self.index[i][j] if self.table[i][j]==self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) else self.index[i][min(j+(1<<i),self.size-1)] for j in range(self.size)]
self.table+=[tmp]
self.index+=[tmp_id]
# return func of [l,r)
def query(self,l,r):
if r>self.size:r=self.size
#N=(r-l).bit_length()-1
N=self.lg[r-l]
return self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))])
# return index of which val[i] = func of v among [l,r)
def query_id(self,l,r):
if r>self.size:r=self.size
#N=(r-l).bit_length()-1
N=self.lg[r-l]
a,b=self.index[N][l],self.index[N][max(0,r-(1<<N))]
if self.table[0][a]==self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))]):
b=a
return b
def __str__(self):
return str(self.table[0])
def print(self):
for i in self.table:
print(*i)
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.size=n
self.ide_ele=ide
self.num=1<<(self.size-1).bit_length()
self.table=[self.ide_ele]*2*self.num
self.index=[0]*2*self.num
self.lazy=[self.ide_ele]*2*self.num
self.func=function
#set_val
if not hasattr(init_val,"__iter__"):
init_val=[init_val]*self.size
for i,val in enumerate(init_val):
self.table[i+self.num-1]=val
self.index[i+self.num-1]=i
#build
for i in range(self.num-2,-1,-1):
self.table[i]=self.func(self.table[2*i+1],self.table[2*i+2])
if self.table[i]==self.table[i*2+1]:
self.index[i]=self.index[i*2+1]
else:
self.index[i]=self.index[i*2+2]
def update(self,k,x):
k+=self.num-1
self.table[k]=x
while k:
k=(k-1)//2
res=self.func(self.table[k*2+1],self.table[k*2+2])
self.table[k]=res
if res==self.table[k*2+1]:
self.index[k]=self.index[k*2+1]
else:
self.index[k]=self.index[k*2+2]
def evaluate(k,l,r): #遅延評価処理
if lazy[k]!=0:
node[k]+=lazy[k]
if(r-l>1):
lazy[2*k+1]+=lazy[k]//2
lazy[2*k+2]+=lazy[k]//2
lazy[k]=0
def query(self,p,q):
if q<=p:
return self.ide_ele
p+=self.num-1
q+=self.num-2
res=self.ide_ele
while q-p>1:
if p&1==0:
res=self.func(res,self.table[p])
if q&1==1:
res=self.func(res,self.table[q])
q-=1
p=p>>1
q=(q-1)>>1
if p==q:
res=self.func(res,self.table[p])
else:
res=self.func(self.func(res,self.table[p]),self.table[q])
return res
def query_id(self,p,q):
if q<=p:
return self.ide_ele
p+=self.num-1
q+=self.num-2
res=self.ide_ele
idx=p
while q-p>1:
if p&1==0:
res=self.func(res,self.table[p])
if res==self.table[p]:
idx=self.index[p]
if q&1==1:
res=self.func(res,self.table[q])
if res==self.table[q]:
idx=self.index[q]
q-=1
p=p>>1
q=(q-1)>>1
if p==q:
res=self.func(res,self.table[p])
if res==self.table[p]:
idx=self.index[p]
else:
res=self.func(self.func(res,self.table[p]),self.table[q])
if res==self.table[p]:
idx=self.index[p]
elif res==self.table[q]:
idx=self.index[q]
return idx
def __str__(self):
# 生配列を表示
rt=self.table[self.num-1:self.num-1+self.size]
return str(rt)
show_flg=False
show_flg=True
ans=0
n,m=LI()
s=[int(i) for i in input()]
def dp(b,m): # N log (N)
N=len(b)-1
n=N+1
sg=SegTree(n,inf,min,inf)
sg.update(0,0)
dp=[0]+[inf]*(N)
for i in range(N):
if b[i+1]==1:
continue
dp[i+1]=sg.query(max(i-m+1,0),i+1)+1
sg.update(i+1,dp[i+1])
return dp
dp1=dp(s,m)
step=dp1[n]
if step==inf:
print(-1)
exit()
dp2=dp(s[::-1],m)[::-1]
move=[0]
ans=[]
j=1
for i in range(step,0,-1): # N
while j<=n and dp2[j]!=i-1:
j+=1
move.append(j)
for i in range(len(move)-1):
ans.append(move[i+1]-move[i])
print(*ans)
exit()
| import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:
a,b=inp;c=1
else:
a,b,c=inp
if index==1:a-=1;b-=1
aa=(a,c);bb=(b,c);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(n,base=2):
rt=[]
for tb in range(base**n):s=[tb//(base**bt)%base for bt in range(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
read=sys.stdin.buffer.read
readline=sys.stdin.buffer.readline
input=lambda: sys.stdin.readline().rstrip()
class Tree:
def __init__(self,inp_size=None,ls=None,init=True,index=0):
self.LCA_init_stat=False
self.ETtable=[]
if init:
if ls==None:
self.stdin(inp_size,index=index)
else:
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls,index=index)
return
def stdin(self,inp_size=None,index=1):
if inp_size==None:
self.size=int(input())
else:
self.size=inp_size
self.edges,_=GI(self.size,self.size-1,index=index)
return
def listin(self,ls,index=0):
self.size=len(ls)+1
self.edges,_=GI(self.size,self.size-1,ls,index=index)
return
def __str__(self):
return str(self.edges)
def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
q=deque()
q.append(x)
v=[-1]*self.size
v[x]=root_v
while q:
c=q.pop()
for nb,d in self.edges[c]:
if v[nb]==-1:
q.append(nb)
v[nb]=func(v[c],nb,d)
return v
def EulerTour(self,x):
q=deque()
q.append(x)
self.depth=[None]*self.size
self.depth[x]=0
self.ETtable=[]
self.ETdepth=[]
self.ETin=[-1]*self.size
self.ETout=[-1]*self.size
cnt=0
while q:
c=q.pop()
if c<0:
ce=~c
else:
ce=c
for nb,d in self.edges[ce]:
if self.depth[nb]==None:
q.append(~ce)
q.append(nb)
self.depth[nb]=self.depth[ce]+1
self.ETtable.append(ce)
self.ETdepth.append(self.depth[ce])
if self.ETin[ce]==-1:
self.ETin[ce]=cnt
else:
self.ETout[ce]=cnt
cnt+=1
return
def LCA_init(self,root):
self.EulerTour(root)
#self.st=SparseTable(self.ETdepth,init_func=min,init_idl=inf)
self.st=SegTree(self.size*2-1,self.ETdepth,function=min,ide=inf)
self.LCA_init_stat=True
return
def LCA(self,root,x,y):
if self.LCA_init_stat==False:
self.LCA_init(root)
xin,xout=self.ETin[x],self.ETout[x]
yin,yout=self.ETin[y],self.ETout[y]
a=min(xin,yin)
b=max(xout,yout,xin,yin)
id_of_min_dep_in_et=self.st.query_id(a,b+1)
return self.ETtable[id_of_min_dep_in_et]
class SparseTable: # O(N log N) for init, O(1) for query(l,r)
def __init__(self,ls,init_func=min,init_idl=float('inf')):
self.func=init_func
self.idl=init_idl
self.size=len(ls)
self.N0=self.size.bit_length()
self.table=[ls[:]]
self.index=[list(range(self.size))]
self.lg=[0]*(self.size+1)
for i in range(2,self.size+1):
self.lg[i]=self.lg[i>>1]+1
for i in range(self.N0):
tmp=[self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) for j in range(self.size)]
tmp_id=[self.index[i][j] if self.table[i][j]==self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) else self.index[i][min(j+(1<<i),self.size-1)] for j in range(self.size)]
self.table+=[tmp]
self.index+=[tmp_id]
# return func of [l,r)
def query(self,l,r):
if r>self.size:r=self.size
#N=(r-l).bit_length()-1
N=self.lg[r-l]
return self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))])
# return index of which val[i] = func of v among [l,r)
def query_id(self,l,r):
if r>self.size:r=self.size
#N=(r-l).bit_length()-1
N=self.lg[r-l]
a,b=self.index[N][l],self.index[N][max(0,r-(1<<N))]
if self.table[0][a]==self.func(self.table[N][l],self.table[N][max(0,r-(1<<N))]):
b=a
return b
def __str__(self):
return str(self.table[0])
def print(self):
for i in self.table:
print(*i)
## Segment Tree ##
## Test case: ABC 146 F
## https://atcoder.jp/contests/abc146/tasks/abc146_f
## Initializer Template ##
# Range Sum: sg=SegTree(n)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.size=n
self.ide_ele=ide
self.num=1<<(self.size-1).bit_length()
self.table=[self.ide_ele]*2*self.num
self.index=[0]*2*self.num
self.lazy=[self.ide_ele]*2*self.num
self.func=function
#set_val
if not hasattr(init_val,"__iter__"):
init_val=[init_val]*self.size
for i,val in enumerate(init_val):
self.table[i+self.num-1]=val
self.index[i+self.num-1]=i
#build
for i in range(self.num-2,-1,-1):
self.table[i]=self.func(self.table[2*i+1],self.table[2*i+2])
if self.table[i]==self.table[i*2+1]:
self.index[i]=self.index[i*2+1]
else:
self.index[i]=self.index[i*2+2]
def update(self,k,x):
k+=self.num-1
self.table[k]=x
while k:
k=(k-1)//2
res=self.func(self.table[k*2+1],self.table[k*2+2])
self.table[k]=res
def evaluate(k,l,r): #遅延評価処理
if lazy[k]!=0:
node[k]+=lazy[k]
if(r-l>1):
lazy[2*k+1]+=lazy[k]//2
lazy[2*k+2]+=lazy[k]//2
lazy[k]=0
def query(self,p,q):
if q<=p:
return self.ide_ele
p+=self.num-1
q+=self.num-2
res=self.ide_ele
while q-p>1:
if p&1==0:
res=self.func(res,self.table[p])
if q&1==1:
res=self.func(res,self.table[q])
q-=1
p=p>>1
q=(q-1)>>1
if p==q:
res=self.func(res,self.table[p])
else:
res=self.func(self.func(res,self.table[p]),self.table[q])
return res
def query_id(self,p,q):
if q<=p:
return self.ide_ele
p+=self.num-1
q+=self.num-2
res=self.ide_ele
idx=p
while q-p>1:
if p&1==0:
res=self.func(res,self.table[p])
if res==self.table[p]:
idx=self.index[p]
if q&1==1:
res=self.func(res,self.table[q])
if res==self.table[q]:
idx=self.index[q]
q-=1
p=p>>1
q=(q-1)>>1
if p==q:
res=self.func(res,self.table[p])
if res==self.table[p]:
idx=self.index[p]
else:
res=self.func(self.func(res,self.table[p]),self.table[q])
if res==self.table[p]:
idx=self.index[p]
elif res==self.table[q]:
idx=self.index[q]
return idx
def __str__(self):
# 生配列を表示
rt=self.table[self.num-1:self.num-1+self.size]
return str(rt)
show_flg=False
show_flg=True
ans=0
n,m=LI()
s=[int(i) for i in input()]
def dp(b,m): # N log (N)
N=len(b)-1
n=N+1
sg=SegTree(n,inf,min,inf)
sg.update(0,0)
dp=[0]+[inf]*(N)
for i in range(N):
if b[i+1]==1:
continue
dp[i+1]=sg.query(max(i-m+1,0),i+1)+1
sg.update(i+1,dp[i+1])
return dp
dp1=dp(s,m)
step=dp1[n]
if step==inf:
print(-1)
exit()
dp2=dp(s[::-1],m)[::-1]
move=[0]
ans=[]
j=1
for i in range(step,0,-1): # N
while j<=n and dp2[j]!=i-1:
j+=1
move.append(j)
for i in range(len(move)-1):
ans.append(move[i+1]-move[i])
print(*ans)
exit()
| p02852 |
from collections import deque
INF = 10**18
def append_dq(i, x, dq, dp1):
while True:
if not len(dq):
dq.append(i)
break
lxi = dq[-1]
if x > dp1[lxi]:
dq.append(i)
break
dq.pop()
return dq
dq = deque()
N,M = list(map(int, input().split()))
S = input().strip()
dp1 = [0] + [INF]*N
dp2 = [[] for _ in range(N+1)]
dq.append(0)
for i, c in enumerate(S[1:]):
i+=1
dq = append_dq(i, dp1[i], dq, dp1)
idx = dq[0]
if c != "1" and dp1[idx] != INF:
dp1[i] = dp1[idx] + 1
dp2[i] = dp2[idx] + [i-idx]
if i >= M:
sxi = dq[0]
if sxi == (i - M):
dq.popleft()
if dp1[-1] == INF:
print((-1))
else:
print((" ".join(map(str, dp2[-1]))))
| from collections import deque
INF = 10**18
def append_dq(i, x, dq, dp1):
while True:
if not len(dq):
dq.append(i)
break
lxi = dq[-1]
if x > dp1[lxi]:
dq.append(i)
break
dq.pop()
return dq
dq = deque()
N,M = list(map(int, input().split()))
S = input().strip()
dp1 = [0] + [INF]*N
dp2 = [-1 for _ in range(N+1)]
dq.append(0)
for i, c in enumerate(S[1:]):
i+=1
dq = append_dq(i, dp1[i], dq, dp1)
idx = dq[0]
if c != "1" and dp1[idx] != INF:
dp1[i] = dp1[idx] + 1
dp2[i] = idx
if i >= M:
sxi = dq[0]
if sxi == (i - M):
dq.popleft()
if dp1[-1] == INF:
print((-1))
else:
r = []
s = N
while True:
if s == 0:
break
ns = dp2[s]
r.append(s-ns)
s = ns
print((" ".join(map(str, r[::-1]))))
| p02852 |
from collections import deque
INF = 10**18
def append_dq(i, x, dq, dp1):
while True:
if not len(dq):
dq.append(i)
break
lxi = dq[-1]
if x > dp1[lxi]:
dq.append(i)
break
dq.pop()
return dq
dq = deque()
N,M = list(map(int, input().split()))
S = input().strip()
dp1 = [0] + [INF]*N
dp2 = [-1 for _ in range(N+1)]
dq.append(0)
for i, c in enumerate(S[1:]):
i+=1
dq = append_dq(i, dp1[i], dq, dp1)
idx = dq[0]
if c != "1" and dp1[idx] != INF:
dp1[i] = dp1[idx] + 1
dp2[i] = idx
if i >= M:
sxi = dq[0]
if sxi == (i - M):
dq.popleft()
if dp1[-1] == INF:
print((-1))
else:
r = []
s = N
while True:
if s == 0:
break
ns = dp2[s]
r.append(s-ns)
s = ns
print((" ".join(map(str, r[::-1]))))
| N,M=map(int,input().split())
S,r,s=input(),[],N
for _ in range(2*N):
if S[s]=='1':
s += 1
else:
r.append(str(N-s))
N,s=s,max(0,s-M)
if N == 0:
break
print(*[-1] if s else r[1:][::-1])
| p02852 |
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, M: int, S: str):
# 最短手数を求める
DP = [INF]*(N+1)
DP[0] = 0
for i in range(1, N+1):
if S[i] == "1":
continue
for j in range(1, M+1):
if i-j < 0:
break
DP[i] = min(DP[i], DP[i-j]+1)
if DP[-1] == INF:
print(-1)
return
# 逆順に辿って実際の手を求める
# 辞書順になるよう、後ろから貪欲に選ぶ
ans = []
curr = N
while curr > 0:
for i in range(M, 0, -1):
if curr-i < 0:
continue
if curr-i == 0:
break
if DP[curr-i] < DP[curr]:
break
curr = curr - i
ans.append(i)
print(*reversed(ans), sep=" ")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(N, M, S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, M: int, S: str):
S = S[::-1]
data = [0]*(N+1)
past = 0
for i in range(N+1):
if S[i] == "1":
data[i] = past
else:
past = i
ans = []
curr = 0
while True:
ne = curr+M
if ne >= N:
ans.append(N-curr)
break
if S[ne] == "1":
ne = data[ne]
if ne <= curr:
print(-1)
return
ans.append(ne - curr)
curr = ne
print(*reversed(ans), sep=" ")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(N, M, S)
if __name__ == '__main__':
main()
| p02852 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.