input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def c_Sentou(N, T, t):
ans = 0
for i in range(N):
if i == N - 1:
ans += T
continue
ans += min(T, t[i + 1] - t[i])
return ans
N,T = [int(i) for i in input().split()]
t = [int(i) for i in input().split()]
print((c_Sentou(N, T, t))) | def c_sentou(N, T, time):
time.append(float('inf')) # 番兵
ans = 0
for i in range(N):
ans += min(T, time[i + 1] - time[i])
return ans
N,T = [int(i) for i in input().split()]
time = [int(i) for i in input().split()]
print((c_sentou(N, T, time))) | p03731 |
def c_sentou(N, T, Times):
times = Times + [Times[-1] + T] # 番兵を追加(最後の人が押したT秒後に止まる)
return sum([min(T, times[i + 1] - times[i]) for i in range(N)])
N, T = [int(i) for i in input().split()]
Time = [int(i) for i in input().split()]
print((c_sentou(N, T, Time))) | def c_sentou():
N, T = [int(i) for i in input().split()]
Times = [int(i) for i in input().split()] + [float('inf')] # 番兵追加
return sum([min(T, Times[i + 1] - Times[i]) for i in range(N)])
print((c_sentou())) | p03731 |
def resolve():
n,t=list(map(int,input().split()))
T=list(map(int,input().split()))
ans=t
for i in range(1,n):
if T[i]-T[i-1]>t:
ans+=t
else:
ans+=T[i]-T[i-1]
print(ans)
resolve() |
def resolve():
n,t=list(map(int,input().split()))
T=list(map(int,input().split()))
T.append(T[-1]+10**10)
ans=0
for i in range(n):
if T[i+1]-T[i]>t:
ans+=t
else:
ans+=T[i+1]-T[i]
print(ans)
resolve() | p03731 |
import sys
input = sys.stdin.readline
from collections import deque
class Unionfindtree:
def __init__(self, number,L):
self.par = [i for i in range(number)]
self.rank = [0] * (number)
self.count = L
def find(self, x): # 親を探す
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y): # x,yを繋げる
px = self.find(x)
py = self.find(y)
if px == py:
return
if self.rank[px] < self.rank[py]:
self.par[px] = py
self.count[py]+=self.count[px]
else:
self.par[py] = px
self.count[px]+=self.count[py]
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
def connect(self, x, y): # 親が同じかみる
return self.find(x) == self.find(y)
N,M=list(map(int,input().split()))
X=[int(i) for i in input().split()]
que=[]
table=[[] for i in range(N)]
for i in range(M):
a,b,c=list(map(int,input().split()))
a,b=a-1,b-1
que.append((c,a,b))
que.sort()
T=Unionfindtree(N,X)
ok=deque()
for i in range(M):
c,a,b=que[i]
T.union(a,b)
if T.count[T.find(a)]>=c:
ok.append(i)
for i in range(M):
c,a,b=que[i]
table[a].append((b,c,i))
table[b].append((a,c,i))
used=[0]*M
def dfs(i,lim):
used[i]=1
c,a,b=que[i]
H=deque()
H.append(b)
H.append(a)
while H:
x=H.popleft()
for y,c,i in table[x]:
if used[i]==1:
continue
if c>lim:
continue
H.append(y)
used[i]=1
return
while ok:
i=ok.pop()
if used[i]==0:
c,a,b=que[i]
dfs(i,c)
print((M-sum(used)))
| import sys
input = sys.stdin.readline
from collections import deque
class Unionfindtree:
def __init__(self, number,L):
self.par = [i for i in range(number)]
self.rank = [0] * (number)
self.cost = L
self.count = [0] * (number)
def find(self, x): # 親を探す
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y): # x,yを繋げる
px = self.find(x)
py = self.find(y)
if px == py:
self.count[py]+=1
return
if self.rank[px] < self.rank[py]:
self.par[px] = py
self.cost[py]+=self.cost[px]
self.count[py]+=self.count[px]+1
else:
self.par[py] = px
self.cost[px]+=self.cost[py]
self.count[px]+=self.count[py]+1
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
def connect(self, x, y): # 親が同じかみる
return self.find(x) == self.find(y)
N,M=list(map(int,input().split()))
X=[int(i) for i in input().split()]
que=[]
table=[[] for i in range(N)]
for i in range(M):
a,b,c=list(map(int,input().split()))
a,b=a-1,b-1
que.append((c,a,b))
que.sort()
T=Unionfindtree(N,X)
used=0
for i in range(M):
c,a,b=que[i]
T.union(a,b)
if T.cost[T.find(a)]>=c:
used+=T.count[T.find(a)]
T.count[T.find(a)]=0
#print(T.count)
#print(T.par)
print((M-used))
| p03143 |
from collections import deque
N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(M)]
EDGE.sort(key=lambda x:x[2])
EDGELIST = [[] for i in range(N+1)]
for i in range(M):
x, y, w = EDGE[i]
EDGELIST[x].append(i)
EDGELIST[y].append(i)
Group = [i for i in range(N+1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
USE = [0]*M
WEIGHTSUM = [0] + [X[i] for i in range(N)]
QUE = deque()
for i in range(M):
x, y, w = EDGE[i]
if find(x) != find(y):
WEIGHTSUM[find(x)] = WEIGHTSUM[find(y)] = WEIGHTSUM[find(x)] + WEIGHTSUM[find(y)]
Union(x, y)
if w <= WEIGHTSUM[find(x)]:
QUE.append(i)
while QUE:
q = QUE.pop()
x, y, w = EDGE[q]
NQUE = deque([q])
while NQUE:
nq = NQUE.pop()
if USE[nq] == 1:
continue
x, y, _ = EDGE[nq]
for e in EDGELIST[x] + EDGELIST[y]:
if EDGE[e][2] <= w:
NQUE.append(e)
USE[nq] = 1
print((USE.count(0)))
| import sys
input = sys.stdin.readline
from collections import deque
N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(M)]
EDGE.sort(key=lambda x:x[2])
EDGELIST = [[] for i in range(N+1)]
for i in range(M):
x, y, w = EDGE[i]
EDGELIST[x].append(i)
EDGELIST[y].append(i)
Group = [i for i in range(N+1)]
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
USE = [0]*M
WEIGHTSUM = [0] + [X[i] for i in range(N)]
QUE = deque()
for i in range(M):
x, y, w = EDGE[i]
if find(x) != find(y):
WEIGHTSUM[find(x)] = WEIGHTSUM[find(y)] = WEIGHTSUM[find(x)] + WEIGHTSUM[find(y)]
Union(x, y)
if w <= WEIGHTSUM[find(x)]:
QUE.append(i)
while QUE:
q = QUE.pop()
x, y, w = EDGE[q]
NQUE = deque([q])
while NQUE:
nq = NQUE.pop()
if USE[nq] == 1:
continue
x, y, _ = EDGE[nq]
for e in EDGELIST[x] + EDGELIST[y]:
if EDGE[e][2] <= w:
NQUE.append(e)
USE[nq] = 1
print((USE.count(0)))
| p03143 |
import sys
sys.setrecursionlimit(10**6)
N, M = list(map(int, input().split()))
*X, = list(map(int, input().split()))
E = []
for i in range(M):
a, b, y = list(map(int, input().split()))
E.append((y, a-1, b-1))
E.sort()
*p, = list(range(N))
Z = [0]*M
A = X[:]
C = [-1]*N
def root(x):
if x == p[x]:
return x
p[x] = y = root(p[x])
return y
def unite(x, y):
px = root(x); py = root(y)
if px == py:
return 0
if px < py:
p[py] = px
A[px] += A[py]
else:
p[px] = py
A[py] += A[px]
return 1
G = [None for i in range(M)]
ans = 0
for i, (y, a, b) in enumerate(E):
pa = root(a); pb = root(b)
ca = C[pa]; cb = C[pb]
if unite(a, b):
pa = root(a)
Z[i] = 1
C[pa] = i
#print(">", i, pa, pb, A[pa], y)
if A[pa] < y:
G[i] = []
if ca != -1:
G[i].append(ca)
if cb != -1:
G[i].append(cb)
else:
if A[pa] < y:
G[i] = []
if ca != -1:
G[i].append(ca)
C[pa] = i
sx = sum(X)
#print(Z)
if N > 1:
from collections import deque
que = deque()
if sx < E[C[0]][0]:
que.append(C[0])
#print(G, C)
while que:
v = que.popleft()
#print(v)
if G[v] is not None:
ans += 1
for w in G[v]:
que.append(w)
print(ans) | from collections import deque
import operator
N, M = list(map(int, input().split()))
*X, = list(map(int, input().split()))
E = []
for i in range(M):
a, b, y = list(map(int, input().split()))
E.append((y, a-1, b-1))
E.sort()
*Y, = list(map(operator.itemgetter(0), E))
*p, = list(range(N))
def root(x):
if x == p[x]:
return x
p[x] = y = root(p[x])
return y
A = X[:]
def unite(x, y):
px = root(x); py = root(y)
if px == py:
return 0
if px < py:
p[py] = px
A[px] += A[py]
else:
p[px] = py
A[py] += A[px]
return 1
G = [[] for i in range(M)]
B = [0]*M
C = [-1]*N
ans = 0
for i, (y, a, b) in enumerate(E):
pa = root(a); pb = root(b)
ca = C[pa]; cb = C[pb]
if unite(a, b):
if ca != -1:
G[i].append(ca)
if cb != -1:
G[i].append(cb)
pa = root(a)
else:
if ca != -1:
G[i].append(ca)
B[i] = A[pa]
C[pa] = i
if N > 1 and sum(X) < E[C[0]][0]:
que = deque()
que.append(C[0])
while que:
v = que.popleft()
if B[v] < Y[v]:
ans += 1
que.extend(G[v])
print(ans) | p03143 |
import sys
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self._root(self.table[x])
return self.table[x]
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
def dfs(s, lim):
q = [s]
visited = [False] * n
while q:
v = q.pop()
if visited[v]:
continue
visited[v] = True
for y, u, i in links[v]:
if y > lim:
continue
use[i] = 2
if visited[u]:
continue
q.append(u)
n, m = list(map(int, input().split()))
xxx = list(map(int, input().split()))
links = [set() for _ in [0] * n]
links2 = []
for i, line in enumerate(sys.stdin.readlines()):
a, b, y = list(map(int, line.split()))
a -= 1
b -= 1
links[a].add((y, b, i))
links[b].add((y, a, i))
links2.append((y, a, b, i))
srt_links = sorted(links2)
uft = UnionFind(n)
connected_sum = xxx[:]
use = [0] * m # 0: ambiguous, 1: usable, 2: fixed
for y, a, b, i in srt_links:
if uft.find(a, b):
r = uft._root(a)
else:
ra = uft._root(a)
rb = uft._root(b)
uft.union(a, b)
r = uft._root(a)
connected_sum[r] += connected_sum[rb if r == ra else ra]
if connected_sum[r] >= y:
use[i] = 1
ans = 0
for y, a, b, i in reversed(srt_links):
if use[i] == 2:
continue
if use[i] == 0:
ans += 1
continue
dfs(a, y)
print(ans)
| import sys
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self._root(self.table[x])
return self.table[x]
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
def dfs(s, lim):
q = [s]
visited[s] = True
while q:
v = q.pop()
for y, u, i in links[v]:
if y > lim:
continue
use[i] = 2
if visited[u]:
continue
visited[u] = True
q.append(u)
n, m = list(map(int, input().split()))
xxx = list(map(int, input().split()))
links = [set() for _ in [0] * n]
links2 = []
for i, line in enumerate(sys.stdin.readlines()):
a, b, y = list(map(int, line.split()))
a -= 1
b -= 1
links[a].add((y, b, i))
links[b].add((y, a, i))
links2.append((y, a, b, i))
srt_links = sorted(links2)
uft = UnionFind(n)
connected_sum = xxx[:]
use = [0] * m # 0: ambiguous, 1: usable, 2: fixed
for y, a, b, i in srt_links:
if uft.find(a, b):
r = uft._root(a)
else:
ra = uft._root(a)
rb = uft._root(b)
uft.union(a, b)
r = uft._root(a)
connected_sum[r] += connected_sum[rb if r == ra else ra]
if connected_sum[r] >= y:
use[i] = 1
ans = 0
visited = [False] * n
for y, a, b, i in reversed(srt_links):
if use[i] == 2:
continue
if use[i] == 0:
ans += 1
continue
dfs(a, y)
print(ans)
| p03143 |
class UnionFindVerSize():
def __init__(self, N,init,M):
""" N個のノードのUnion-Find木を作成する """
# 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる
self._parent = [n for n in range(0, N)]
# グループのサイズ（個数）
self._size = [1] * N
self._weight=init
self._set=[[0,0] for i in range(N)]
self._edge=M
def find_root(self, x):
""" xの木の根(xがどのグループか)を求める """
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x]) # 縮約
return self._parent[x]
def unite(self, x, y,i):
""" xとyの属するグループを併合する """
gx = self.find_root(x)
gy = self.find_root(y)
m=self._edge
if gx == gy:
a,b=self._set[gx]
if i>=m//2:
a=a|pow(2,i-m//2)
else:
b=b|pow(2,i)
self._set[gx]=[a,b]
return
# 小さい方を大きい方に併合させる（木の偏りが減るので）
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
self._weight[gy]+=self._weight[gx]
self._set[gy][0]=self._set[gy][0]|self._set[gx][0]
self._set[gy][1]=self._set[gy][1]|self._set[gx][1]
if i>=m//2:
self._set[gy][0]=self._set[gy][0]|pow(2,i-m//2)
else:
self._set[gy][1]=self._set[gy][1]|pow(2,i)
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
self._weight[gx]+=self._weight[gy]
self._set[gx][0]=self._set[gy][0]|self._set[gx][0]
self._set[gx][1]=self._set[gy][1]|self._set[gx][1]
if i>=m//2:
self._set[gx][0]=self._set[gx][0]|pow(2,i-m//2)
else:
self._set[gx][1]=self._set[gx][1]|pow(2,i)
def get_size(self, x):
""" xが属するグループのサイズ（個数）を返す """
return self._size[self.find_root(x)]
def get_weight(self,x):
return self._weight[self.find_root(x)]
def get_set(self,x):
return self._set[self.find_root(x)]
def is_same_group(self, x, y):
""" xとyが同じ集合に属するか否か """
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
""" グループ数を計算して返す """
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
weight=list(map(int,input().split()))
edge=[]
for i in range(M):
u,v,c=list(map(int,input().split()))
edge.append((c,u-1,v-1))
edge.sort()
uf=UnionFindVerSize(N,weight,M)
a=0
b=0
for i in range(M):
c,u,v=edge[i]
uf.unite(u,v,i)
if uf.get_weight(u)>=c:
A,B=uf.get_set(u)
a=a|A
b=b|B
ok=a<<M//2 |b
ans=M-bin(ok).count("1")
print(ans) | class UnionFindVerSize():
def __init__(self, N,init):
""" N個のノードのUnion-Find木を作成する """
# 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる
self._parent = [n for n in range(0, N)]
self._size = [1] *N
# グループのサイズ（個数）
self._weight=init
self._set=[[0,0] for i in range(N)]
def find_root(self, x):
""" xの木の根(xがどのグループか)を求める """
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x]) # 縮約
return self._parent[x]
def unite(self, x, y):
""" xとyの属するグループを併合する """
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy:return
# 小さい方を大きい方に併合させる（木の偏りが減るので）
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._weight[gy]+=self._weight[gx]
self._size[gy]+=self._size[gx]
self._set[gy][0]+=self._set[gx][0]
self._set[gy][1]+=self._set[gx][1]
else:
self._parent[gy] = gx
self._weight[gx]+=self._weight[gy]
self._size[gx]+=self._size[gy]
self._set[gx][0]+=self._set[gy][0]
self._set[gx][1]+=self._set[gy][1]
def add(self,i,u,key):
x=self.find_root(u)
if key:
self._set[x][0]+=self._set[x][1]+1
self._set[x][1]=0
else:
self._set[x][1]+=1
def get_size(self, x):
""" xが属するグループのサイズ（個数）を返す """
return self._size[self.find_root(x)]
def get_weight(self,x):
return self._weight[self.find_root(x)]
def get_set(self,x):
return self._set[self.find_root(x)]
def is_same_group(self, x, y):
""" xとyが同じ集合に属するか否か """
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
""" グループ数を計算して返す """
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
weight=list(map(int,input().split()))
edge=[]
for i in range(M):
u,v,c=list(map(int,input().split()))
edge.append((c,u-1,v-1))
edge.sort()
uf=UnionFindVerSize(N,weight)
for i in range(M):
c,u,v=edge[i]
uf.unite(u,v)
uf.add(i,u,uf.get_weight(u)>=c)
no=uf.get_set(0)[1]
print(no) | p03143 |
def main():
import heapq
n, m = list(map(int, input().split()))
x = list(map(int, input().split()))
aby = [list(map(int, input().split())) for _ in [0]*m]
aby = [(a-1, b-1, y) for a, b, y in aby]
tree1 = [sum(x)]
tree2 = [0]*n
def Kruskal(n, abc, weight=False):
class unionfind():
# size:要素数,tree：unionfind木
def __init__(self, size): # self,要素数
self.size = size
self.tree_root = list(range(self.size))
self.tree_depth = [1]*self.size
# rootを探す
def root(self, index):
temp_list = []
temp = self.tree_root[index]
while index != temp:
temp_list.append(index)
index = temp
temp = self.tree_root[index]
for i in temp_list:
self.tree_root[i] = index
return index
# 結合
def unite(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
if r1 != r2:
d1, d2 = self.tree_depth[r1], self.tree_depth[r2]
if d1 <= d2:
self.tree_root[r1] = r2
self.tree_depth[r2] = max(d1+1, d2)
else:
self.tree_root[r2] = r1
self.tree_depth[r1] = max(d2+1, d1)
# 同じか判定
def same(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
return r1 == r2
uf = unionfind(n)
ret = []
if weight:
abc.sort(key=lambda x: x[2])
for a, b, *c in abc:
if not uf.same(a, b):
ret.append((a, b, c[0]))
uf.unite(a, b)
return ret
def dfs(a, b):
g[a].remove(b)
g[b].remove(a)
tree_a, tree_b, q_a, q_b, sum_a, sum_b = {a}, {b}, [a], [b], x[a], x[b]
while True:
flag = False
while q_a:
i = q_a[-1]
for j in g[i]:
if j not in tree_a:
q_a.append(j)
tree_a.add(j)
sum_a += x[j]
flag = True
break
if flag:
break
else:
q_a.pop()
if not q_a:
l = len(tree1)
for i in tree_a:
tree2[i] = l
tree1.append(sum_a)
tree1[tree2[b]] -= sum_a
return
flag = False
while q_b:
i = q_b[-1]
for j in g[i]:
if j not in tree_b:
q_b.append(j)
tree_b.add(j)
sum_b += x[j]
flag = True
break
if flag:
break
else:
q_b.pop()
if not q_b:
l = len(tree1)
for i in tree_b:
tree2[i] = l
tree1.append(sum_b)
tree1[tree2[a]] -= sum_b
return
min_tree = Kruskal(n, aby, True)
g = [set() for _ in [0]*n]
[g[a].add(b) for a, b, y in min_tree]
[g[b].add(a) for a, b, y in min_tree]
h = [(-y, a, b) for a, b, y in min_tree]
heapq.heapify(h)
ans = len(min_tree)
while h:
y, a, b = heapq.heappop(h)
y *= -1
if y > tree1[tree2[a]]:
dfs(a, b)
ans -= 1
for a, b, y in set(aby)-set(min_tree):
if tree2[a] == tree2[b]:
if y <= tree1[tree2[a]]:
ans += 1
print((m-ans))
main()
| def main():
from sys import stdin
input = stdin.readline
import heapq
n, m = list(map(int, input().split()))
x = list(map(int, input().split()))
aby = [list(map(int, input().split())) for _ in [0]*m]
aby = [(a-1, b-1, y) for a, b, y in aby]
tree1 = [sum(x)]
tree2 = [0]*n
def Kruskal(n, abc):
class unionfind():
# size:要素数,tree：unionfind木
def __init__(self, size): # self,要素数
self.size = size
self.tree_root = list(range(self.size))
self.tree_depth = [1]*self.size
# rootを探す
def root(self, index):
temp_list = []
temp = self.tree_root[index]
while index != temp:
temp_list.append(index)
index = temp
temp = self.tree_root[index]
for i in temp_list:
self.tree_root[i] = index
return index
# 結合
def unite(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
if r1 != r2:
d1, d2 = self.tree_depth[r1], self.tree_depth[r2]
if d1 <= d2:
self.tree_root[r1] = r2
self.tree_depth[r2] = max(d1+1, d2)
else:
self.tree_root[r2] = r1
self.tree_depth[r1] = max(d2+1, d1)
# 同じか判定
def same(self, index1, index2):
r1 = self.root(index1)
r2 = self.root(index2)
return r1 == r2
uf = unionfind(n)
ret = []
abc.sort(key=lambda x: x[2])
for a, b, c in abc:
if not uf.same(a, b):
ret.append((a, b, c))
uf.unite(a, b)
return ret
def dfs(a, b):
g[a].remove(b)
g[b].remove(a)
tree_a, tree_b, q_a, q_b, sum_a, sum_b = {a}, {b}, [a], [b], x[a], x[b]
while True:
flag = False
while q_a:
i = q_a[-1]
for j in g[i]:
if j not in tree_a:
q_a.append(j)
tree_a.add(j)
sum_a += x[j]
flag = True
break
if flag:
break
else:
q_a.pop()
if not q_a:
l = len(tree1)
for i in tree_a:
tree2[i] = l
tree1.append(sum_a)
tree1[tree2[b]] -= sum_a
return
flag = False
while q_b:
i = q_b[-1]
for j in g[i]:
if j not in tree_b:
q_b.append(j)
tree_b.add(j)
sum_b += x[j]
flag = True
break
if flag:
break
else:
q_b.pop()
if not q_b:
l = len(tree1)
for i in tree_b:
tree2[i] = l
tree1.append(sum_b)
tree1[tree2[a]] -= sum_b
return
min_tree = Kruskal(n, aby)
g = [set() for _ in [0]*n]
[g[a].add(b) for a, b, y in min_tree]
[g[b].add(a) for a, b, y in min_tree]
h = [(-y, a, b) for a, b, y in min_tree]
heapq.heapify(h)
ans = len(min_tree)
while h:
y, a, b = heapq.heappop(h)
y *= -1
if y > tree1[tree2[a]]:
dfs(a, b)
ans -= 1
for a, b, y in set(aby)-set(min_tree):
if tree2[a] == tree2[b]:
ans += y <= tree1[tree2[a]]
print((m-ans))
main()
| p03143 |
def solve():
MOD = 998244353
N, K = list(map(int, input().split()))
S = set()
for i in range(K):
_l, _r = list(map(int, input().split()))
_s = set(list(range(_l, _r+1)))
S |= _s
# dp[i] : iに到達する経路数
dp = [0] * (N+1)
dp[1] = 1
for i in range(2, N+1):
for d in S:
if i-d > 0:
dp[i] = (dp[i] + dp[i-d]) % MOD
print((dp[N]))
solve()
|
def solve():
MOD = 998244353
N, K = list(map(int, input().split()))
LR_L = [[int(x) for x in input().split()] for y in range(K)]
# S = set()
# for i in range(K):
# _l, _r = map(int, input().split())
# _s = set(list(range(_l, _r+1)))
# S |= _s
# dp[i] : iに到達する経路数
dp = [0] * (N+1)
dp[1] = 1
dp[2] = -1
for i in range(1, N+1):
dp[i] += dp[i-1]
dp[i] %= MOD
# for d in S:
# if i-d > 0:
# dp[i] = (dp[i] + dp[i-d]) % MOD
for li, ri in LR_L:
if i + li < N+1:
dp[i+li] += dp[i]
dp[i+li] %= MOD
if i + ri + 1 < N+1:
dp[i+ri+1] -= dp[i]
dp[i+ri+1] %= MOD
print((dp[N]))
solve()
| p02549 |
N,K=list(map(int,input().split()))
MOD = 998244353
dp = [0]*(N+1)
LR = []
for _ in range(K):
l, r = list(map(int, input().split()))
LR.append((l,r))
LR.sort()
dp[1] = 1
dp_sum = [0]*(N+1) # dp[i]の累積和
dp_sum[1] = 1
for i in range(2, N+1):
for l, r in LR:
if i - l >= 1:
dp[i] += dp_sum[i-l] - dp_sum[max(0, i-r-1)]
dp[i] %= MOD
dp[i] %= MOD
dp_sum[i] = dp_sum[i-1] + dp[i]
print((dp[N]%MOD)) | N,K=list(map(int,input().split()))
MOD = 998244353
dp = [0]*(N*3)
LR = []
for _ in range(K):
l, r = list(map(int, input().split()))
LR.append((l,r))
LR.sort()
imos = [0]*(N*3)
dp[1] = 1
imos[1] = 1
for i in range(1, N):
if i >= 2:
dp[i+1] += dp[i]
for l, r in LR:
dp[i+l] += dp[i]
dp[i+l] %= MOD
dp[i+r+1] -= dp[i]
dp[i+r+1] %= MOD
print((dp[N]%MOD))
| p02549 |
N, K = [int(v) for v in input().split()]
links = []
for k in range(K):
L, R = [int(v) for v in input().split()]
links.append((L, R))
links = sorted(links, key=lambda x: x[1])
count = [1]
sub = [0, 1]
subtotal = 1
for i in range(1, N):
v = 0
for l, r in links:
r2 = i - l + 1
l2 = i - r
if l2 < 0:
l2 = 0
if r2 >= 0:
v += sub[r2] - sub[l2]
count.append(v % 998244353)
subtotal += v
sub.append(subtotal)
print((count[-1]))
| N, K = [int(v) for v in input().split()]
links = []
for k in range(K):
L, R = [int(v) for v in input().split()]
links.append((L, R))
links = sorted(links, key=lambda x: x[1])
count = [1]
sub = [0, 1]
subtotal = 1
for i in range(1, N):
v = 0
for l, r in links:
r2 = i - l + 1
l2 = i - r
if l2 < 0:
l2 = 0
if r2 >= 0:
v += sub[r2] - sub[l2]
count.append(v % 998244353)
subtotal = (subtotal + v) % 998244353
sub.append(subtotal )
print((count[-1]))
| p02549 |
import sys
sys.setrecursionlimit(10 ** 9)
n,k = list(map(int,input().split()))
s = []
for i in range(k):
l,r = list(map(int,input().split()))
s.append((l,r))
MOD = 998244353
memo = [-1 for _ in range(n+1)]
def f(x):
if x < 1:
return 0
if x == 1:
return 1
if memo[x] != -1:
return memo[x]
res = 0
for l,r in s:
for i in range(l,r+1):
res += f(x-i)
res %= MOD
memo[x] = res
return res
print((f(n)))
| import sys
sys.setrecursionlimit(10 ** 9)
n,k = list(map(int,input().split()))
s = []
for i in range(k):
l,r = list(map(int,input().split()))
s.append((l,r))
s.sort()
MOD = 998244353
memo = [-1 for _ in range(n+1)]
def f(x):
if x < 1:
return 0
if x == 1:
return 1
if memo[x] != -1:
return memo[x]
res = 0
for l,r in s:
for i in range(l,r+1):
res += f(x-i)
res %= MOD
memo[x] = res
return res
print((f(n)))
| p02549 |
def main():
n, k = list(map(int, input().split()))
mod = 998244353
dp = [0] * (n + 1)
dp[1] = 1
delta = []
for _ in range(k):
l, r = list(map(int, input().split()))
for i in range(l, r + 1):
delta.append(i)
delta.sort()
for i in range(n):
for d in delta:
if i + d > n:
break
dp[i + d] += dp[i]
dp[i + d] %= mod
print((dp[n]))
if __name__ == '__main__':
main()
| def main():
n, k = list(map(int, input().split()))
mod = 998244353
dp = [0] * (n + 1)
dp[1] = 1
dp[2] = -1
left = [0] * k
right = [0] * k
for i in range(k):
left[i], right[i] = list(map(int, input().split()))
right[i] += 1
for i in range(1, n + 1):
dp[i] += dp[i - 1]
for j in range(k):
if i + left[j] <= n:
dp[i + left[j]] += dp[i]
if i + right[j] <= n:
dp[i + right[j]] -= dp[i]
dp[i] %= mod
print((dp[n]))
if __name__ == '__main__':
main()
| p02549 |
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
MOD = 998244353
n, k = list(map(int, input().split()))
dp = [0] * n
dp[0] = 1
dp[1] = -1
delta = []
for _ in range(k):
l, r = list(map(int, input().split()))
delta.append((l, 1))
delta.append((r+1, -1))
total = 0
for i in range(n):
total += dp[i]
for p, d in delta:
if i + p >= n:
continue
dp[i + p] += total * d
print((total % MOD)) | #!/usr/bin/env python3
import sys
input = sys.stdin.readline
MOD = 998244353
n, k = list(map(int, input().split()))
dp = [0] * n
dp[0] = 1
dp[1] = -1
delta = []
for _ in range(k):
l, r = list(map(int, input().split()))
delta.append((l, 1))
delta.append((r+1, -1))
total = 0
for i in range(n):
total += dp[i]
total %= MOD
for p, d in delta:
if i + p >= n:
continue
dp[i + p] += total * d
dp[i + p] %= MOD
print((total % MOD)) | p02549 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
mod = 998244353
dp = [0]*N
dp[0] = 1
ok = [0]*(N+1)
for _ in range(K):
l, r = mapint()
ok[l-1] += 1
ok[r] -= 1
from itertools import accumulate
ok = list(accumulate(ok))
lis = [i for i in range(1, N+1) if ok[i-1]]
for i in range(N):
for d in lis:
if i-d>=0:
dp[i] += dp[i-d]
dp[i] %= mod
print((dp[-1])) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
mod = 998244353
dp = [0]*(N+1)
dp[1] = 1
Ks = [list(mapint()) for _ in range(K)]
Ks.sort()
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sums(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bit = Bit(N)
bit.add(1, 1)
for i in range(2, N+1):
for l, r in Ks:
if i-l<0:
break
dp[i] += bit.sums(i-l) - bit.sums(max(0, i-r-1))
dp[i] %= mod
bit.add(i, dp[i])
print((dp[-1])) | p02549 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
mod = 998244353
dp = [0]*(N+1)
dp[1] = 1
Ks = [list(mapint()) for _ in range(K)]
Ks.sort()
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sums(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bit = Bit(N)
bit.add(1, 1)
for i in range(2, N+1):
for l, r in Ks:
if i-l<0:
break
dp[i] += bit.sums(i-l) - bit.sums(max(0, i-r-1))
dp[i] %= mod
bit.add(i, dp[i])
print((dp[-1])) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
dp = [0]*(N*3+1)
dp[1] = 1
dp[2] = -1
mod = 998244353
LR = [list(mapint()) for _ in range(K)]
for i in range(1, N+1):
dp[i] = (dp[i]+dp[i-1])%mod
for l, r in LR:
dp[i+l] = (dp[i+l]+dp[i])%mod
dp[i+r+1] = (dp[i+r+1]-dp[i])%mod
print((dp[N])) | p02549 |
N, K = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(K)]
MOD = 998244353
dp = [0] * (N + 1)
dp[1] = 1
for i in range(1, N):
for l, r in X:
for k in range(l, r + 1):
if i + k > N:
break
dp[i + k] += dp[i]
dp[i + k] %= MOD
print((dp[-1]))
|
N, K = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(K)]
MOD = 998244353
dp = [0] * N
sdp = [0] * (N + 1)
dp[0] = 1
sdp[1] = 1
for i in range(1, N):
for l, r in X:
dp[i] += sdp[max(0, i - l + 1)] - sdp[max(0, i - r)]
dp[i] %= MOD
sdp[i + 1] = sdp[i] + dp[i]
sdp[i + 1] %= MOD
print((dp[-1]))
| p02549 |
# coding:UTF-8
import sys
from math import factorial
MOD = 998244353
INF = 10000000000
def main():
n, k = list(map(int, input().split())) # スペース区切り連続数字
lrList = [list(map(int, input().split())) for _ in range(k)] # スペース区切り連続数字(行列)
s = []
for l, r in lrList:
for i in range(l, r+1):
s.append(i)
Interm = [0] * (n + 1)
Interm[0] = 0
Interm[1] = 1
for i in range(1, n+1):
if i >= 2:
for j in s:
if n - j >= 1:
Interm[i] = (Interm[i] + Interm[i - j]) % 998244353
result = Interm[n]
# ------ 出力 ------#
print(("{}".format(result)))
if __name__ == '__main__':
main()
| # coding:UTF-8
import sys
from math import factorial
MOD = 998244353
INF = 10000000000
def main():
n, k = list(map(int, input().split())) # スペース区切り連続数字
lrList = [list(map(int, input().split())) for _ in range(k)] # スペース区切り連続数字(行列)
s = []
for l, r in lrList:
for i in range(l, r+1):
s.append(i)
s.sort()
sum = [0] * (n + 1)
Interm = [0] * (2 * n + 1)
sum[1] = 1
for i in range(1, n):
for j in range(k):
l, r = lrList[j][0], lrList[j][1]
Interm[i+l] += sum[i]
Interm[i+r+1] -= sum[i]
sum[i+1] = (sum[i] + Interm[i+1]) % MOD
# result = Interm[n]
result = (sum[n] - sum[n-1]) % MOD
# ------ 出力 ------#
print(("{}".format(result)))
if __name__ == '__main__':
main()
| p02549 |
def main():
n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n+1);
dp[0] = 1
dp[1] = -1
for i in range(0, n):
if i>0: dp[i] += dp[i-1]
for l,r in lr:
if i+l > n: continue
dp[i+l] += dp[i]
dp[min(n, i+r+1)] -= dp[i]
print((dp[n-1] % 998244353))
main()
| n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n+1);
dp[0] = 1
dp[1] = -1
for i in range(0, n):
if i>0: dp[i] += dp[i-1]
dp[i] %= 998244353
for l,r in lr:
if i+l > n: continue
dp[i+l] += dp[i]
dp[min(n, i+r+1)] -= dp[i]
print((dp[-2] % 998244353))
| p02549 |
MOD = 998244353
N, K = list(map(int, input().split()))
L = []
R = []
for k in range(K):
l, r = list(map(int, input().split()))
L += [l]
R += [r]
# memo = [[0 for i in range(N+2)] for k in range(K)]
memo = [0 for i in range(N+2)]
memo[1] = 1
memo[2] = -1
cusum = 0
for i in range(1, N+1):
cusum += memo[i]
# print(cusum)
for k in range(K):
l, r = L[k], R[k]
# for j in range(i+l, min(i+r+1, N+1)):
# memo[j] += memo[i]
memo[min(i+l, N+1)] += cusum
memo[min(i+r+1, N+1)] -= cusum
# print(memo)
# for i in range(1, N+1):
# for k in range(K):
# memo[k][i+1] += memo[k][i]
print((cusum % MOD)) | MOD = 998244353
N, K = list(map(int, input().split()))
L = []
R = []
for k in range(K):
l, r = list(map(int, input().split()))
L += [l]
R += [r]
# memo = [[0 for i in range(N+2)] for k in range(K)]
memo = [0 for i in range(N+2)]
memo[1] = 1
memo[2] = -1
cusum = 0
for i in range(1, N+1):
cusum = (cusum + memo[i]) % MOD
# print(cusum)
for k in range(K):
l, r = L[k], R[k]
# for j in range(i+l, min(i+r+1, N+1)):
# memo[j] += memo[i]
memo[min(i+l, N+1)] += cusum
memo[min(i+r+1, N+1)] -= cusum
# print(memo)
# for i in range(1, N+1):
# for k in range(K):
# memo[k][i+1] += memo[k][i]
print((cusum % MOD)) | p02549 |
#dpで素直にやるとO(N^2)だから、累積和で高速化しO(KN)にする
n, k = list(map(int,input().split()))
mod = 998244353
s = []
for i in range(k):
s.append(list(map(int,input().split())))
cnt = [0]*n
cnt[0] = 1
sum = [0]*n
sum[0] = 1
for i in range(1,n):
for j in range(k):
if i > s[j][1]:
cnt[i] += sum[i-s[j][0]] - sum[i-s[j][1]-1]
elif i >= s[j][0]:
cnt[i] += sum[i-s[j][0]]
sum[i] = sum[i-1] + cnt[i]
print((cnt[-1] % mod)) | #dpで素直にやるとO(N^2)だから、累積和で高速化しO(KN)にする
n, k = list(map(int,input().split()))
mod = 998244353
s = []
for i in range(k):
s.append(list(map(int,input().split())))
cnt = [0]*n
cnt[0] = 1
sum = [0]*n
sum[0] = 1
for i in range(1,n):
for j in range(k):
if i > s[j][1]:
cnt[i] += sum[i-s[j][0]] - sum[i-s[j][1]-1]
elif i >= s[j][0]:
cnt[i] += sum[i-s[j][0]]
cnt[i] %= mod
sum[i] = (sum[i-1] + cnt[i]) % mod
print((cnt[-1])) | p02549 |
N,K=list(map(int,input().split()))
S=[]
NUM=998244353
for _ in range(K):
l,r=list(map(int,input().split()))
for i in range(l,r+1):
S.append(i)
S.sort()
dp=[0]*(N+1)
dp[1]=1
for i in range(2,N+1):
for s in S:
if i-s<=0: break
dp[i]+=dp[i-s]
dp[i]%=NUM
print((dp[N]))
| N,K=list(map(int,input().split()))
S=[list(map(int,input().split())) for _ in range(K)]
NUM=998244353
dp=[0]*(N+1)
dp[1]=1
sums=[0]*(N+1)
sums[1]=1
for i in range(2,N+1):
for s in S:
_l,_r=i-s[0],i-s[1]-1
if _l<0:
continue
elif _r<0:
_r=0
dp[i]+=sums[_l]-sums[_r]
dp[i]%=NUM
sums[i]=dp[i]+sums[i-1]
sums[i]%=NUM
print((dp[N]))
| p02549 |
import sys
input = sys.stdin.readline
class FenwickTree:
def __init__(self, size):
self.bit = [0] * (size + 1)
self.size = size
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.bit[i]
s %= mod
i -= i & -i
return s
def add(self, i, x):
i += 1
while i <= self.size:
self.bit[i] += x
self.bit[i] %= mod
i += i & -i
mod = 998244353
N, K = list(map(int, input().split()))
L, R = list(zip(*[list(map(int, input().split())) for _ in range(K)]))
dp = FenwickTree(N + 1)
dp.add(1, 1)
dp.add(2, -1)
for i in range(1, N):
x = dp.sum(i)
for j in range(K):
dp.add(i + L[j], x)
if i + R[j] + 1 <= N:
dp.add(i + R[j] + 1, -x)
print((dp.sum(N))) | import sys
input = sys.stdin.readline
mod = 998244353
N, K = list(map(int, input().split()))
L, R = list(zip(*[list(map(int, input().split())) for _ in range(K)]))
dp = [0] * (N + 1)
dp[1] = 1
dp[2] = -1
x = 0
for i in range(1, N):
x = (x + dp[i]) % mod
for j in range(K):
if i + L[j] > N:
continue
dp[i + L[j]] = (dp[i + L[j]] + x) % mod
if i + R[j] + 1 <= N:
dp[i + R[j] + 1] = (dp[i + R[j] + 1] - x) % mod
x = (x + dp[N]) % mod
print(x) | p02549 |
n,k=list(map(int,input().split()))
S = {}
for i in range(k):
tmp = list(map(int,input().split()))
lr = list(range(tmp[0],tmp[1]+1))
S = set(lr).union(S)
MOD = 998244353
dp = [0]*(n+1)
dp[1] = 1
for i in range(1,n+1):
for j in S:
if i-j > 0:
dp[i] += dp[i-j]%MOD
print((dp[n]%MOD)) | n,k=list(map(int,input().split()))
lr=[list(map(int,input().split())) for _ in range(k)]
mod = 998244353
dp = [0] * (n+1)
sdp = [0] * (n+1)
dp[1] = 1
sdp[1] = 1
for i in range(n+1):
for j in range(k):
left = max(0, i-lr[j][1])
right = max(0, i-lr[j][0]+1)
dp[i] += sdp[right] - sdp[left]
if i+1 <= n:
sdp[i+1] = sdp[i]%mod + dp[i]%mod
print((dp[n]%mod)) | p02549 |
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from sys import exit
import sys
sys.setrecursionlimit(1000000000)
mod = 998244353
#############
# Main Code #
#############
#####segfunc#####
def segfunc(x, y):
return min(x, y)
#################
#####ide_ele#####
ide_ele = 2 ** 63 - 1
#################
class LazySegmentTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
add(l, r, x): 区間[l, r)にxを加算 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
num: n以上の最小の2のべき乗
data: 値配列(1-index)
lazy: 遅延配列(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.data = [ide_ele] * 2 * self.num
self.lazy = [0] * 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).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
"""
遅延伝搬処理
ids: 伝搬する対象の区間
"""
for i in reversed(ids):
v = self.lazy[i]
if not v:
continue
self.lazy[2 * i] += v
self.lazy[2 * i + 1] += v
self.data[2 * i] += v
self.data[2 * i + 1] += v
self.lazy[i] = 0
def add(self, l, r, x):
"""
区間[l, r)の値にxを加算
l, r: index(0-index)
x: additional value
"""
*ids, = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.data[l] += x
l += 1
if r & 1:
self.lazy[r - 1] += x
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]) + self.lazy[i]
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
*ids, = self.gindex(l, r)
self.propagates(*ids)
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.data[l])
l += 1
if r & 1:
res = self.segfunc(res, self.data[r - 1])
l >>= 1
r >>= 1
return res
# 1 ~ Nまで
N, K = getNM()
que = [getList() for i in range(K)]
# 通りの数を求める問題
# dp？
# 組み合わせ？
# goの要素を足して行ってN = 1を達成できればいい
# ただしgoの数が多い
# ナップサックは無理
# 重複あり部分和
# 部分和の通り
# どうすればN - 1の組み合わせができるか
# ソートする？
# 足し合わせ？
dp = [0] * (N + 1)
seg = LazySegmentTree([0] * (N + 1), segfunc, ide_ele)
dp[1] = 1
seg.add(1, 2, 1)
# dpする
for i in range(1, N):
dp[i] = seg.query(i, i + 1) % mod
for l, r in que:
if i + l <= N:
seg.add(i + l, min(i + r + 1, N + 1), dp[i])
else:
continue
print((seg.query(N, N + 1) % mod)) | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from sys import exit
import sys
sys.setrecursionlimit(1000000000)
mod = 998244353
#############
# Main Code #
#############
N, K = getNM()
que = [getList() for i in range(K)]
dp = [0] * (N + 1)
dp[1] = 1
dp[2] = -1
for i in range(1, N + 1):
dp[i] += dp[i - 1]
dp[i] %= mod
for l, r in que:
if i + l <= N:
dp[i + l] += dp[i]
if i + r + 1 <= N:
dp[i + r + 1] -= dp[i]
print((dp[N] % mod)) | p02549 |
n,k = list(map(int,input().split()))
st = set([])
for i in range(k):
x,y = list(map(int,input().split()))
for z in range(x,y+1):
st.add(z)
ans = [1]
for i in range(1,n):
s = 0
for x in st:
if i >= x:
s = s + ans[i-x]
ans.append(s % 998244353)
print((ans[-1]))
| n,k = list(map(int,input().split()))
st = []
for i in range(k):
x,y = list(map(int,input().split()))
st.append((x,y))
total = [1]
for i in range(1,n):
s = 0
for (x,y) in st:
if i > y:
s = (s + total[i-x] - total[i-y-1]) % 998244353
elif i >= x:
s = (s + total[i-x]) % 998244353
total.append((s+total[-1]) % 998244353)
print(((total[-1]-total[-2]) % 998244353))
| p02549 |
n , k = list(map(int, input().split()))
li = [0]*(n+2)
lis = []
lis2 =[0]*(3*n)
lis2[1]=1
for i in range(k):
l,r = list(map(int, input().split()))
for j in range(l,r+1):
lis.append(j)
for i in range(1,n+1):
for j in lis:
lis2[i]%=998244353
lis2[i+j]+=lis2[i]
print((lis2[n]))
| n , k = list(map(int, input().split()))
li = [0]*(n+2)
lis = []
lr=[]
lis2 =[0]*(3*n)
lis2[1]=1
lis2[2]=-1
for i in range(k):
l,r = list(map(int, input().split()))
lr.append((l,r))
for i in range(1,n+1):
lis2[i]+=lis2[i-1]
lis2[i]%=998244353
for j,k in lr:
lis2[i+j]+=lis2[i]
lis2[i+k+1]-=lis2[i]
print((lis2[n]%998244353))
| p02549 |
n,k = (int(x) for x in input().split())
s = []
for _ in range(k):
a,b = (int(x) for x in input().split())
s+=list(range(a,b+1))
mod = 998244353
l = [0]*(n)
s = sorted(s)
min_num = s[0]
for i in range(min_num,n):
for j in s:
if j < i:
l[i] += (l[i-j])
if i in s:
l[i] += 1
l[i] %= mod
print((l[n-1])) | n,k = (int(x) for x in input().split())
lr = []
for _ in range(k):
l,r = (int(x) for x in input().split())
lr.append((l,r))
lr.sort()
mod = 998244353
dp= [0]*(n+1)
dp[1] = 1
for i in range(2,n+1):
cnt = 0
for l,r in lr:
if l >= i:
break
else:
cnt += dp[i-l] - dp[max(0,i-r-1)]
dp[i] = (dp[i-1] + cnt) % mod
print((cnt%mod)) | p02549 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
class Bit:
def __init__(self, a):
if hasattr(a, "__iter__"):
le = len(a)
self.n = 1 << le.bit_length()
self.values = values = [0] * (self.n + 1)
values[1:le + 1] = a[:]
for i in range(1, self.n):
values[i + (i & -i)] += values[i]
elif isinstance(a, int):
self.n = 1 << a.bit_length()
self.values = [0] * (self.n + 1)
else:
raise TypeError
# A[i] += val
def add(self, i, val):
n, values = self.n, self.values
while i <= n:
values[i] += val
i += i & -i
# A[1, i]の累積和
def sum(self, i):
values = self.values
res = 0
while i > 0:
res += values[i]
i -= i & -i
return res
# A[1, i]の累積和 が v 以上になる最小の i
def bisect_left(self, v):
n, values = self.n, self.values
if v > values[n]:
return None
i, step = 0, n >> 1
while step:
if values[i + step] < v:
i += step
v -= values[i]
step >>= 1
return i + 1
def main():
N, K = in_nn()
LR = []
for i in range(K):
l, r = in_nn()
LR.append((l, r))
init_dp = [0] * N
init_dp[0] = 1
init_dp[1] = -1
bit = Bit(init_dp)
for i in range(1, N + 1):
for k in range(K):
l, r = LR[k]
now = bit.sum(i)
bit.add(i + l, now)
bit.add(i + r + 1, -now)
print((bit.sum(N) % 998244353))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
class Bit:
def __init__(self, a):
if hasattr(a, "__iter__"):
le = len(a)
self.n = 1 << le.bit_length()
self.values = values = [0] * (self.n + 1)
values[1:le + 1] = a[:]
for i in range(1, self.n):
values[i + (i & -i)] += values[i]
elif isinstance(a, int):
self.n = 1 << a.bit_length()
self.values = [0] * (self.n + 1)
else:
raise TypeError
# A[i] += val
def add(self, i, val):
n, values = self.n, self.values
while i <= n:
values[i] += val
i += i & -i
# A[1, i]の累積和
def sum(self, i):
values = self.values
res = 0
while i > 0:
res += values[i]
i -= i & -i
return res
# A[1, i]の累積和 が v 以上になる最小の i
def bisect_left(self, v):
n, values = self.n, self.values
if v > values[n]:
return None
i, step = 0, n >> 1
while step:
if values[i + step] < v:
i += step
v -= values[i]
step >>= 1
return i + 1
def main():
N, K = in_nn()
LR = []
for i in range(K):
l, r = in_nn()
LR.append((l, r))
init_dp = [0] * N
init_dp[0] = 1
init_dp[1] = -1
bit = Bit(init_dp)
mod = 998244353
for i in range(1, N + 1):
for k in range(K):
l, r = LR[k]
now = bit.sum(i) % mod
bit.add(i + l, now)
bit.add(i + r + 1, -now)
print((bit.sum(N) % mod))
if __name__ == '__main__':
main()
| p02549 |
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 8)
N, K = list(map(int, input().split()))
M = 998244353
S = set()
for _ in range(K):
L, R = list(map(int, input().split()))
for i in range(L, R + 1):
S.add(i)
@lru_cache(None)
def dp(i):
if i < 1:
return 0
elif i == 1:
return 1
else:
res = 0
for d in S:
res += dp(i - d)
res %= M
return res
print((dp(N) % M)) | N, K =list(map(int,input().split()))
K = [tuple(map(int,input().split())) for i in range(K)]
M = 998244353
dp = [0] * N
dp[1] = 1
prefix = [1] * N
for i in range(1, N):
cur = 0
for L, R in K:
a = i - R
b = i - L
if b < 0:
continue
cur += prefix[b] - (prefix[a - 1] if a - 1 >= 0 else 0)
dp[i] = cur % M
prefix[i] = prefix[i - 1] + dp[i]
prefix[i] %= M
print((dp[N - 1])) | p02549 |
class BIT:
def __init__(self, n, MOD):
self.n = n
self.data = [0] * (n + 1)
self.MOD = MOD
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
s %= self.MOD
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
self.data[i] %= self.MOD
i += i & -i
n, k = list(map(int, input().split()))
mod = 998244353
bit = BIT(n + 2, mod)
ranges = []
for _ in range(k):
l, r = list(map(int, input().split()))
ranges.append((l, r))
bit.add(1, 1)
for i in range(1, n):
v = bit.sum(i)
for l, r in ranges:
bit.add(i + l, v)
bit.add(min(n + 1, i + r + 1), -v)
print((bit.sum(n) - bit.sum(n - 1) % mod))
| class BIT:
def __init__(self, n, MOD):
self.n = n
self.data = [0] * (n + 1)
self.MOD = MOD
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
s %= self.MOD
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
self.data[i] %= self.MOD
i += i & -i
n, k = list(map(int, input().split()))
mod = 998244353
bit = BIT(n + 2, mod)
ranges = []
for _ in range(k):
l, r = list(map(int, input().split()))
ranges.append((l, r))
bit.add(1, 1)
for i in range(1, n):
v = bit.sum(i)
for l, r in ranges:
bit.add(i + l, v)
bit.add(min(n + 1, i + r + 1), -v)
print(((bit.sum(n) - bit.sum(n - 1)) % mod))
| p02549 |
class BIT:
def __init__(self, n, MOD):
self.n = n
self.data = [0] * (n + 1)
self.MOD = MOD
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
s %= self.MOD
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
self.data[i] %= self.MOD
i += i & -i
n, k = list(map(int, input().split()))
mod = 998244353
bit = BIT(n + 2, mod)
ranges = []
for _ in range(k):
l, r = list(map(int, input().split()))
ranges.append((l, r))
bit.add(1, 1)
for i in range(1, n):
v = bit.sum(i)
for l, r in ranges:
bit.add(i + l, v)
bit.add(min(n + 1, i + r + 1), -v)
print(((bit.sum(n) - bit.sum(n - 1)) % mod))
| class BIT:
def __init__(self, n, MOD):
self.n = n
self.data = [0] * (n + 1)
self.MOD = MOD
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
s %= self.MOD
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
self.data[i] %= self.MOD
i += i & -i
def diff(self, i, j):
s = self.sum(j) - self.sum(i)
s %= self.MOD
return s
n, k = list(map(int, input().split()))
mod = 998244353
bit = BIT(n + 2, mod)
ranges = []
for _ in range(k):
l, r = list(map(int, input().split()))
ranges.append((l, r))
bit.add(1, 1)
for i in range(1, n):
v = bit.sum(i)
for l, r in ranges:
bit.add(i + l, v)
bit.add(min(n + 1, i + r + 1), -v)
print((bit.diff(n - 1, n)))
| p02549 |
N, K = list(map(int, input().split()))
MOD = 998244353
lr = []
for _ in range(K):
l, r = list(map(int, input().split()))
lr.append((l, r))
lr.sort()
dp = [0]*(N+1)
dpsum = [0]*(N+1)
dp[1] = 1
dpsum[1] = 1
# 区間の合計を複数回求める＝累積和
# 累積和を作りながらDPをする
for i in range(2, N+1):
# マスiに移動できる数を求める
for l, r in lr:
# iの左側からiへ移動できる区間を求めるので、
# lとrは逆になる
li = max(i-r, 1)
ri = i-l
# 右のマスが0以下なら移動できないので次へ
if li < 1:
continue
dp[i] += dpsum[ri]-dpsum[li-1]
dp[i] %= MOD
dpsum[i] = dpsum[i-1]+dp[i]
print((dp[N]))
| N, K = list(map(int, input().split()))
MOD = 998244353
lr = []
for _ in range(K):
l, r = list(map(int, input().split()))
lr.append((l, r))
lr.sort()
dp = [0]*(N+1)
dpsum = [0]*(N+1)
dp[1] = 1
dpsum[1] = 1
# 区間の合計を複数回求める＝累積和
# 累積和を作りながらDPをする
for i in range(2, N+1):
# マスiに移動できる数を求める
for l, r in lr:
# iの左側からiへ移動できる区間を求めるので、
# lとrは逆になる
li = max(i-r, 1)
ri = i-l
# 右のマスが0以下なら移動できないので次へ
if ri < 1:
continue
dp[i] += dpsum[ri]-dpsum[li-1]
dp[i] %= MOD
dpsum[i] = dpsum[i-1]+dp[i]
print((dp[N]))
| p02549 |
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(eval(input()))
def i_map(): return list(map(int, input().split()))
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return eval(input())
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
# MOD = 10 ** 9 + 7
MOD = 998244353
num_list = []
str_list = []
def main():
n, k = i_map()
num_list = i_row_list(k)
dp = [0] * (n+1)
dp_sum = [0] * (n+1)
dp[1] = 1
dp_sum[1] = 1
for i in range(2, n+1):
for j in range(k):
li = i - num_list[j][1]
ri = i - num_list[j][0]
if ri < 0:
continue
li = max(li, 0)
dp[i] += dp_sum[ri] - dp_sum[li-1]
dp_sum[i] = dp_sum[i-1] + dp[i]
print((dp[n]%MOD))
if __name__ == '__main__':
main()
| import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(eval(input()))
def i_map(): return list(map(int, input().split()))
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return eval(input())
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
# MOD = 10 ** 9 + 7
MOD = 998244353
num_list = []
str_list = []
def main():
n, k = i_map()
num_list = i_row_list(k)
dp = [0] * (n+1)
dp_sum = [0] * (n+1)
dp[1] = 1
dp_sum[1] = 1
for i in range(2, n+1):
for j in range(k):
li = i - num_list[j][1]
ri = i - num_list[j][0]
if ri < 0:
continue
li = max(li, 0)
dp[i] += dp_sum[ri] - dp_sum[li-1]
dp[i] %= MOD
dp_sum[i] = dp_sum[i-1] + dp[i]
print((dp[n]%MOD))
if __name__ == '__main__':
main()
| p02549 |
MOD=998244353
N,K=list(map(int,input().split()))
lrlist=[]
for _ in range(K):
l,r=list(map(int,input().split()))
lrlist.append((l,r))
#print(lrlist)
#A1～Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
#初期化
BIT=[0]*(N+1)
BIT_update(1,1)
for i in range(2,N+1):
for l,r in lrlist:
left=i-r
right=i-l
if right<1:
continue
elif left<1:
left=1
sum_intv=BIT_query(right)-BIT_query(left-1)
BIT_update(i,sum_intv)
print(((BIT_query(N)-BIT_query(N-1))%MOD)) | MOD=998244353
N,K=list(map(int,input().split()))
lrlist=[]
for _ in range(K):
l,r=list(map(int,input().split()))
lrlist.append((l,r))
#print(lrlist)
#A1～Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
#初期化
BIT=[0]*(N+1)
BIT_update(1,1)
for i in range(2,N+1):
for l,r in lrlist:
left=i-r
right=i-l
if right<1:
continue
elif left<1:
left=1
sum_intv=BIT_query(right)-BIT_query(left-1)
BIT_update(i,sum_intv)
nomod=BIT_query(i)-BIT_query(i-1)
BIT_update(i,nomod%MOD-nomod)
print((BIT_query(N)-BIT_query(N-1))) | p02549 |
N, K = list(map(int,input().split()))
LR = [tuple(map(int,input().split())) for _ in range(K)]
d = [0]*N
ans = [0]*N
ans[0] = 1
MOD = 998244353
for i in range(N):
x = ans[i]
for k in range(K):
L, R = LR[k]
if i+L < len(d):
d[i+L] += x
d[i+L] %= MOD
if i+R+1 < len(d):
d[i+R+1] -= x
d[i+R+1] %= MOD
for j in range(i+2, len(d)):
d[j] += d[j-1]
d[j] %= MOD
for j in range(len(d)):
ans[j] = (ans[j]+d[j]) % MOD
d[j] = 0
print((ans[-1] % MOD)) | N, K = list(map(int,input().split()))
LR = [tuple(map(int,input().split())) for _ in range(K)]
d = [0]*N
d[0] = 1
MOD = 998244353
for i in range(N-1):
x = d[i]
d[0] = 0
for k in range(K):
L, R = LR[k]
if i+L < len(d):
d[i+L] += x
d[i+L] %= MOD
if i+R+1 < len(d):
d[i+R+1] -= x
d[i+R+1] %= MOD
d[i+1] += d[i]
d[i+1] %= MOD
print((d[-1] % MOD)) | p02549 |
MOD = 998244353
N, K = list(map(int,input().split()))
S = []
for _ in range(K):
L, R = list(map(int,input().split()))
for i in range(L,R+1):
if i not in S:
S.append(i)
# dp[i]: マスiに移動する方法
dp = [0] * 200010
dp[0] = 1
for i in range(N):
for d in S:
if i+d < N:
dp[i+d] += dp[i]
dp[i+d] %= MOD
print((dp[N-1]))
| MOD = 998244353
N, K = list(map(int,input().split()))
LR = [list(map(int,input().split())) for _ in range(K)]
# dp[i]: マスiに移動する方法
dp = [0] * 200010
dp[0] = 1
for i in range(N):
for l, r in LR:
if i+l < N:
dp[i+l] += dp[i]
dp[i+l] %= MOD
if i+r < N:
dp[i+r+1] -= dp[i]
dp[i+r+1] %= MOD
if i>=1:
dp[i+1] += dp[i]
dp[i+1] %= MOD
print((dp[N-1]))
| p02549 |
def getsum(BITTree, i):
s = 0 # initialize result
# index in BITree[] is 1 more than the index in arr[]
i = i + 1
# Traverse ancestors of BITree[index]
while i > 0:
# Add current element of BITree to sum
s += BITTree[i]
# Move index to parent node in getSum View
i -= i & (-i)
return s
# Updates a node in Binary Index Tree (BITree) at given index
# in BITree. The given value 'val' is added to BITree[i] and
# all of its ancestors in tree.
def updatebit(BITTree, n, i, v):
# index in BITree[] is 1 more than the index in arr[]
i += 1
# Traverse all ancestors and add 'val'
while i <= n:
# Add 'val' to current node of BI Tree
BITTree[i] += v
# Update index to that of parent in update View
i += i & (-i)
# Constructs and returns a Binary Indexed Tree for given
# array of size n.
def construct(arr, n):
# Create and initialize BITree[] as 0
BITTree = [0] * (n + 1)
# Store the actual values in BITree[] using update()
for i in range(n):
updatebit(BITTree, n, i, arr[i])
# Uncomment below lines to see contents of BITree[]
# for i in range(1,n+1):
# print BITTree[i],
return BITTree
n,k=list(map(int,input().split()))
c=[]
a=[0]*(n+1)
a[1]=1
BITTree = construct(a,len(a))
mod=998244353
for i in range(k):
x,y=list(map(int,input().split()))
c.append([x,y])
for i in range(2,n+1):
for j in range(len(c)):
p,q=c[j][0],c[j][1]
if i-q>0:
l,r=i-p,i-q
z=getsum(BITTree,l)-getsum(BITTree,r-1)
a[i]+=z
updatebit(BITTree, len(a), i,z)
else:
q=i-1
if i-q>0 and i-p>0:
l, r = i - p, i - q
z = getsum(BITTree, l) - getsum(BITTree, r - 1)
##z= getsum(BITTree, q) - getsum(BITTree, p - 1)
##print(z)
a[i]+=z
updatebit(BITTree, len(a), i, z)
##print(BITTree)
##print(a)
print((a[n]%mod))
| def getsum(BITTree, i):
s = 0 # initialize result
# index in BITree[] is 1 more than the index in arr[]
i = i + 1
# Traverse ancestors of BITree[index]
while i > 0:
# Add current element of BITree to sum
s += BITTree[i]
# Move index to parent node in getSum View
i -= i & (-i)
return s
# Updates a node in Binary Index Tree (BITree) at given index
# in BITree. The given value 'val' is added to BITree[i] and
# all of its ancestors in tree.
def updatebit(BITTree, n, i, v):
# index in BITree[] is 1 more than the index in arr[]
i += 1
# Traverse all ancestors and add 'val'
while i <= n:
# Add 'val' to current node of BI Tree
BITTree[i] += v
# Update index to that of parent in update View
i += i & (-i)
# Constructs and returns a Binary Indexed Tree for given
# array of size n.
def construct(arr, n):
# Create and initialize BITree[] as 0
BITTree = [0] * (n + 1)
# Store the actual values in BITree[] using update()
for i in range(n):
updatebit(BITTree, n, i, arr[i])
# Uncomment below lines to see contents of BITree[]
# for i in range(1,n+1):
# print BITTree[i],
return BITTree
n,k=list(map(int,input().split()))
c=[]
a=[0]*(n+1)
a[1]=1
BITTree = construct(a,len(a))
mod=998244353
for i in range(k):
x,y=list(map(int,input().split()))
c.append([x,y])
for i in range(2,n+1):
for j in range(len(c)):
p,q=c[j][0],c[j][1]
if i-q>0:
l,r=i-p,i-q
z=(getsum(BITTree,l)-getsum(BITTree,r-1))%mod
a[i]+=z
updatebit(BITTree, len(a), i,z)
else:
q=i-1
if i-q>0 and i-p>0:
l, r = i - p, i - q
z = (getsum(BITTree, l) - getsum(BITTree, r - 1))%mod
##z= getsum(BITTree, q) - getsum(BITTree, p - 1)
##print(z)
a[i]+=z
updatebit(BITTree, len(a), i, z)
##print(BITTree)
##print(a)
print((a[n]%mod))
| p02549 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
MOD = 998244353
def makeBIT(numEle):
numPow2 = 2 ** (numEle-1).bit_length()
data = [0] * (numPow2+1)
return data, numPow2
def setInit(As):
for iB, A in enumerate(As, 1):
data[iB] = A
for iB in range(1, numPow2):
i = iB + (iB & -iB)
data[i] += data[iB]
def addValue(iA, A):
iB = iA + 1
while iB <= numPow2:
data[iB] += A
iB += iB & -iB
def getSum(iA):
iB = iA + 1
ans = 0
while iB > 0:
ans += data[iB]
iB -= iB & -iB
return ans
def getRangeSum(iFr, iTo):
return getSum(iTo) - getSum(iFr-1)
N, K = list(map(int, input().split()))
LRs = [tuple(map(int, input().split())) for _ in range(K)]
data, numPow2 = makeBIT(N)
addValue(0, 1)
for i in range(1, N):
for L, R in LRs:
x, y = i-R, i-L
if y < 0:
continue
if x < 0:
x = 0
v = getRangeSum(x, y)
addValue(i, v)
ans = getRangeSum(N-1, N-1) % MOD
print(ans)
solve()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
MOD = 998244353
def makeBIT(numEle):
numPow2 = 2 ** (numEle-1).bit_length()
data = [0] * (numPow2+1)
return data, numPow2
def setInit(As):
for iB, A in enumerate(As, 1):
data[iB] = A
for iB in range(1, numPow2):
i = iB + (iB & -iB)
data[i] += data[iB]
def addValue(iA, A):
iB = iA + 1
while iB <= numPow2:
data[iB] += A
iB += iB & -iB
def getSum(iA):
iB = iA + 1
ans = 0
while iB > 0:
ans += data[iB]
iB -= iB & -iB
return ans
def getRangeSum(iFr, iTo):
return getSum(iTo) - getSum(iFr-1)
N, K = list(map(int, input().split()))
LRs = [tuple(map(int, input().split())) for _ in range(K)]
data, numPow2 = makeBIT(N)
addValue(0, 1)
for i in range(1, N):
v = 0
for L, R in LRs:
x, y = i-R, i-L
if y < 0:
continue
if x < 0:
x = 0
v += getRangeSum(x, y) % MOD
v %= MOD
addValue(i, v)
ans = getRangeSum(N-1, N-1) % MOD
print(ans)
solve()
| p02549 |
MOD = 998244353
def main():
from bisect import bisect_left
N, K = (int(i) for i in input().split())
S = set()
for _ in range(K):
le, ri = (int(i) for i in input().split())
for i in range(le, ri+1):
S.add(i)
A = sorted(S)
memo = [0] * (N+1)
memo[0] = 1
def dfs(N):
if N < 0:
return 0
if memo[N] != 0:
return memo[N]
ret = 0
idx = bisect_left(A, N)
for i in A[idx::-1]:
ret += dfs(N - i)
ret %= MOD
memo[N] = ret
return ret
print((dfs(N-1)))
# print(memo, A)
if __name__ == '__main__':
main()
| MOD = 998244353
def main():
N, K = (int(i) for i in input().split())
LR = [[int(i) for i in input().split()] for j in range(K)]
dp = [0] * (N+2)
dp[1] = 1
dp[2] = -1
for i in range(1, N+1):
for le, ri in LR:
if i+le <= N:
dp[i+le] += dp[i]
dp[i+le] %= MOD
if i+ri+1 <= N:
dp[i+ri+1] -= dp[i]
dp[i+ri+1] %= MOD
dp[i+1] += dp[i]
dp[i+1] %= MOD
print((dp[N]))
if __name__ == '__main__':
main()
| p02549 |
MOD = 998244353
def main():
N, K = (int(i) for i in input().split())
LR = [[int(i) for i in input().split()] for j in range(K)]
dp = [0] * (N+2)
dp[1] = 1
dp[2] = -1
for i in range(1, N+1):
for le, ri in LR:
if i+le <= N:
dp[i+le] += dp[i]
dp[i+le] %= MOD
if i+ri+1 <= N:
dp[i+ri+1] -= dp[i]
dp[i+ri+1] %= MOD
dp[i+1] += dp[i]
dp[i+1] %= MOD
print((dp[N]))
if __name__ == '__main__':
main()
| MOD = 998244353
def main():
# 配るdp + imos法
N, K = (int(i) for i in input().split())
LR = [[int(i) for i in input().split()] for j in range(K)]
dp = [0] * (N+2)
dp[1] = 1
dp[2] = -1
for i in range(1, N+1):
for le, ri in LR:
if i+le <= N:
dp[i+le] += dp[i]
dp[i+le] %= MOD
if i+ri+1 <= N:
dp[i+ri+1] -= dp[i]
dp[i+ri+1] %= MOD
dp[i+1] += dp[i]
dp[i+1] %= MOD
print((dp[N]))
if __name__ == '__main__':
main()
| p02549 |
n, k = list(map(int, input().split()))
lr = []
for _ in range(k):
l, r = list(map(int, input().split()))
lr.append((l, r))
mod = 998244353
dp = [0]*(2*n+1)
dp[0] = 1
dp[1] = -1
now = 1
for i in range(n):
for l, r in lr:
dp[i+l] += now
dp[i+r+1] -= now
now += dp[i+1]
print((sum(dp[:n])%mod)) | n, k = list(map(int, input().split()))
lr = []
for _ in range(k):
l, r = list(map(int, input().split()))
lr.append((l, r))
mod = 998244353
dp = [0]*(2*n+1)
dp[0] = 1
dp[1] = -1
now = 1
for i in range(n):
for l, r in lr:
dp[i+l] += now
dp[i+r+1] -= now
now += dp[i+1]
now %= mod
ans = 0
for i in range(n):
ans += dp[i]
ans %= mod
print(ans) | p02549 |
n,k = list(map(int,input().split()))
ns = []
for i in range(k):
l, r = list(map(int,input().split()))
for k in range(l, r+1):
ns.append(k)
arr = [0 for i in range(n)]
arr[0] = 1
for i in range(n):
for j in ns:
if i + j < n:
arr[i + j] += arr[i]
print((arr[n-1] % 998244353)) | MOD = 998244353
n,k = list(map(int,input().split()))
ns = [list(map(int,input().split())) for i in range(k)]
dp = [0 for j in range(n+1)]
cum = [0 for j in range(n+1)]
dp[1] = 1
cum[1] = 1
for i in range(2, n+1):
for j in range(k):
l, r = ns[j]
if i - l >= 0:
dp[i] += cum[i-l]
if i - (r+1) >= 0:
dp[i] -= cum[i-(r+1)]
dp[i] = (dp[i] % MOD + MOD) % MOD
cum[i] = (cum[i-1] + dp[i]) % MOD
print((dp[n])) | p02549 |
n, k = list(map(int, input().split()))
s = []
for i in range(k):
l, r = list(map(int, input().split()))
s += list(range(l, r+1))
mod = 998244353
dp = [0] * (n+1)
dp[1] = 1
s = sorted(s)
for i in range(1, n):
dp[i] %= mod
for add in s:
if i+add <= n:
dp[i+add] += dp[i]
print((dp[n] % mod)) | n, k = list(map(int, input().split()))
s = []
for i in range(k):
l, r = list(map(int, input().split()))
s.append([l, r])
mod = 998244353
dp = [0] * (n+1)
cumsum = [0] * (n+1)
dp[1] = 1
s = sorted(s)
counter = 0
for i in range(1, n+1):
counter += cumsum[i]
dp[i] += counter
dp[i] %= mod
for l, r in s:
if i+l <= n:
cumsum[i+l] += dp[i]
if i+r+1 <= n:
cumsum[i+r+1] -= dp[i]
print((dp[n] % mod)) | p02549 |
# -*- 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():
return 0
def op(sl, sr):
return (sl + sr) % M
def mapping(fl, sr):
return (fl + sr) % M
def composition(fl, fr):
return (fl + fr) % M
def im():
return 0
@mt
def slv(N, K, LR):
memo = LazySegmentTree(op, e, mapping, composition, im, [0]*(N+1))
memo.apply(1, 1+1, 1)
for i in range(1, N+1):
n = memo[i]
for l, r in LR:
ll = min(N+1, i+l)
rr = min(N+1, i+r+1)
memo.apply(ll, rr, n)
return memo[N]
def main():
N, K = read_int_n()
LR = [read_int_n() for _ in range(K)]
print(slv(N, K, LR))
if __name__ == '__main__':
main()
| # -*- 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 ModInt:
def __init__(self, x=0, M=10**9+7):
self.m = M
self.x = x % self.m
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x, self.m) if isinstance(other, ModInt) else
ModInt(self.x + other, self.m)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x, self.m) if isinstance(other, ModInt) else
ModInt(self.x - other, self.m)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x, self.m) if isinstance(other, ModInt) else
ModInt(self.x * other, self.m)
)
def __truediv__(self, other):
return (
ModInt(self.x * pow(other.x, self.m - 2, self.m)) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, self.m - 2, self.m))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, self.m)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, self.m))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x, self.m) if isinstance(other, ModInt) else
ModInt(other - self.x, self.m)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(other.x * pow(self.x, self.m - 2, self.m)) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, self.m - 2, self.m))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, self.m)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, self.m))
)
@mt
def slv(N, K, LR):
M = 998244353
memo = [ModInt(0, M)] * (N+2)
memo[1] = 1
memo[1+1] = -1
for i in range(1, N+1):
memo[i] += memo[i-1]
for l, r in LR:
ll = min(N+1, i+l)
rr = min(N+1, i+r+1)
memo[ll] += memo[i]
memo[rr] -= memo[i]
return memo[N]
def main():
N, K = read_int_n()
LR = [read_int_n() for _ in range(K)]
print(slv(N, K, LR))
if __name__ == '__main__':
main()
| p02549 |
N,K = [int(i) for i in input().split()]
mod = 998244353
LR = []
S = []
dp = [0]*(N+1)
dps = [0]*(N+1)
dps[1] = 1
for i in range(K):
LR.append([int(i) for i in input().split()])
rM = 0
for i in range(N):
for lr in LR:
if lr[0] <= i and i <= lr[1]:
S.append(i)
rM = max(rM, lr[1])
for i in range(1,N):
if i in S:
dp[i] = 1
for l,r in LR:
l,r = i - r,i - l
if r < 1:
continue
l = max(0,l)
dp[i] += dps[r] - dps [l-1]
dp[i] %= mod
dps[i] += dps[r] - dps[l]
dps[i] = dps[i-1] + dp[i]
print((dp[-2])) | N,K = [int(i) for i in input().split()]
mod = 998244353
LR = []
S = []
dp = [0]*(N+1)
dps = [0]*(N+1)
dps[1] = 1
dp[1] = 1
for i in range(K):
LR.append([int(i) for i in input().split()])
for i in range(1,N+1):
for l,r in LR:
l,r = i - r,i - l
#print(l,r)
if r < 1:
continue
l = max(1,l)
dp[i] += dps[r] - dps[l-1]
dp[i] %= mod
#print(dp[i])
dps[i] = dps[i-1] + dp[i]
#print(dp, dps)
print((dp[-1])) | p02549 |
import sys
input = sys.stdin.readline
INF = 10**18
sys.setrecursionlimit(10**6)
import itertools as it
import collections as cl
from collections import deque
import math
from functools import reduce
from collections import defaultdict
MOD = 998244353
def li():
return [int(x) for x in input().split()]
N, K = li()
s = set()
for _ in range(K):
a, b = li()
for i in range(a, b+1):
s.add(i)
# dp[i]: マスiに到達する方法の個数
dp = [0] * (N+1)
dp[0] = 1
for i in range(N):
for j in s:
if i + j <= N:
dp[i+j] += dp[i]
dp[i+j] %= MOD
print((dp[N-1]))
| import sys
input = sys.stdin.readline
INF = 10**18
sys.setrecursionlimit(10**6)
import itertools as it
import collections as cl
from collections import deque
import math
from functools import reduce
from collections import defaultdict
MOD = 998244353
def li():
return [int(x) for x in input().split()]
N, K = li()
L, R = [], []
for _ in range(K):
l, r = li()
L.append(l)
R.append(r)
# dp[i]: i番目のマスにいく場合の数
dp = [0] * (N+1)
dp[1] = 1
# 区間 [left, right)の和はdpsum[right] - dpsum[left]
# 区間 [left, right]の和はdpsum[right+1] - dpsum[left]
# マス a~bは区間だと[a-1,b-1]に対応。よってマスliからriの和はdpsum[right] - dpsum[left - 1]
dpsum = [0] * (N+1)
dpsum[1] = 1
for i in range(2, N+1):
for j in range(K):
li = max(i - R[j], 1)
ri = i - L[j]
if ri >= 0:
dp[i] += dpsum[ri] - dpsum[li-1]
dp[i] %= MOD
dpsum[i] = dpsum[i-1] + dp[i]
dpsum[i] %= MOD
print((dp[N]))
| p02549 |
N,K = list(map(int, input().split()))
d = [0]*2*K
for i in range(K):
d[2*i], d[2*i+1] = list(map(int, input().split()))
a=[0]*(N+1)
b=[0]*(N+1)
a[1]=1
b[1]=1
for i in range(2,N+1):
t=0
for j in range(K):
if i-d[2*j]>0:
t+=b[i-d[2*j]]
if i-d[2*j+1]-1>0:
t-=b[i-d[2*j+1]-1]
a[i]=t
b[i]=b[i-1]+a[i]
print((a[N]%998244353)) | N,K = list(map(int, input().split()))
d = [0]*2*K
for i in range(K):
d[2*i], d[2*i+1] = list(map(int, input().split()))
a=[0]*(N+1)
b=[0]*(N+1)
a[1]=1
b[1]=1
for i in range(2,N+1):
t=0
for j in range(K):
if i-d[2*j]>0:
t+=b[i-d[2*j]]
if i-d[2*j+1]-1>0:
t-=b[i-d[2*j+1]-1]
a[i]=t
b[i]=(b[i-1]+a[i])%998244353
print((a[N]%998244353))
| p02549 |
n,k=list(map(int,input().split()))
lst=[list(map(int,input().split())) for i in range(k)]
mod=998244353
dp=[1]
imos=[0]*(2*n+10)
imos[0]=1
imos[1]=-1
for i in range(n):
for l,r in lst:
imos[i+l]+=dp[-1]
imos[i+r+1]-=dp[-1]
dp.append((dp[-1]+imos[i+1])%mod)
print((dp[n-1])) | n,k=list(map(int,input().split()))
lst=[list(map(int,input().split())) for i in range(k)]
mod=998244353
dp=[0]*(2*n+10)
dp[0]=1
dp[1]=-1
for i in range(n):
for l,r in lst:
dp[i+l]+=dp[i]
dp[i+r+1]-=dp[i]
dp[i+1]+=dp[i]
dp[i+1]%=mod
print((dp[n-1])) | p02549 |
n, k = list(map(int, input().split()))
mod = 998244353
list_s = []
for _ in range(k):
l, r = list(map(int, input().split()))
list_s.append((l, r))
dp = [0] * (n + 1)
sdp = [0] * (n + 1)
dp[1] = 1
sdp[0] = 0
sdp[1] = 1
for i in range(2, n + 1):
for l, r in list_s:
dl = max(0, i - r - 1)
dr = max(0, i - l)
dp[i] += sdp[dr] - sdp[dl]
sdp[i] = sdp[i - 1] + dp[i]
print((dp[n] % mod)) | n, k = list(map(int, input().split()))
mod = 998244353
list_s = []
for _ in range(k):
l, r = list(map(int, input().split()))
list_s.append((l, r))
dp = [0] * (n + 1)
sdp = [0] * (n + 1)
dp[1] = 1
sdp[0] = 0
sdp[1] = 1
for i in range(2, n + 1):
for l, r in list_s:
dl = max(0, i - r - 1)
dr = max(0, i - l)
dp[i] += sdp[dr] - sdp[dl]
sdp[i] = (sdp[i - 1] + dp[i]) % mod
print((dp[n] % mod)) | p02549 |
def main():
n, k = list(map(int, input().split()))
ds = set()
for _ in range(k):
l, r = list(map(int, input().split()))
ds = ds | {i for i in range(l, r + 1)}
dp = [0] * (n + 1)
dp[1] = 1
for i in range(1, n + 1):
for d in ds:
if i + d <= n:
dp[i + d] = (dp[i + d] + dp[i]) % 998244353
print((dp[-1] % 998244353))
if __name__ == "__main__":
main()
| def main():
n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n + 1)
dp[1] = 1
dpsum = [0] * (n + 1)
dpsum[1] = 1
mod = 998244353
for i in range(2, n + 1):
for j in range(k):
li = i - lr[j][1]
ri = i - lr[j][0]
if ri < 0:
continue
dp[i] = (dp[i] + dpsum[ri] - dpsum[li - 1]) % mod
dpsum[i] = dpsum[i - 1] + dp[i]
print((dp[-1] % mod))
if __name__ == "__main__":
main()
| p02549 |
n, k = list(map(int, input().split()))
lr = []
for _ in range(k):
lr.append(tuple(map(int, input().split())))
mod = 998244353
dp = [0]*n
dp[0] = 1
acc = [0]*n
acc[0] = 1
for i in range(1, n):
for l, r in lr:
if 0 <= i-r and i-l < i:
dp[i] += acc[i-l]-acc[i-r-1]
elif i-r < 0 and i-l < i:
dp[i] += acc[i-l]
elif i-r < 0 and i <= i-l:
dp[i] += acc[i-1]
elif 0 < i-r and i <= i-l:
dp[i] += acc[i-1]-acc[i-r-1]
acc[i] = acc[i-1]+dp[i]
print((dp[-1]%mod)) | n, k = list(map(int, input().split()))
lr = []
for _ in range(k):
lr.append(tuple(map(int, input().split())))
mod = 998244353
dp = [0]*n
dp[0] = 1
acc = [0]*n
acc[0] = 1
for i in range(1, n):
for l, r in lr:
if 0 <= i-r and i-l < i:
dp[i] += acc[i-l]-acc[i-r-1]
elif i-r < 0 and i-l < i:
dp[i] += acc[i-l]
elif i-r < 0 and i <= i-l:
dp[i] += acc[i-1]
elif 0 < i-r and i <= i-l:
dp[i] += acc[i-1]-acc[i-r-1]
acc[i] = acc[i-1]+dp[i]%mod
print((dp[-1]%mod)) | p02549 |
N, K = list(map(int, input().split()))
MOD = 998244353
P = []
for _ in range(K):
l, r = list(map(int, input().split()))
for i in range(l, r+1):
P.append(i)
dp = [0]*(N+1)
dp[0]=1
for i in range(N):
for p in P:
dp[min(i+p,N)] += dp[i]
dp[min(i + p, N)]%=MOD
print((dp[N-1])) | N, K = list(map(int, input().split()))
MOD = 998244353
D = []
for _ in range(K):
l, r = list(map(int, input().split()))
D.append((l,r))
imos = [0]*(N+2)
dp = [0]*(N+1)
imos[0]=1
imos[1]=-1
for i in range(N):
dp[i] = dp[i-1] + imos[i]
dp[i] %= MOD
for a, b in D:
imos[min(i+a,N+1)] += dp[i]
imos[min(i+b+1,N+1)] -= dp[i]
print((dp[N-1])) | p02549 |
mod = 998244353
n,k = list(map(int,input().split()))
K = [list(map(int,input().split())) for i in range(k)]
dp = [0]*(n+5)
dp[1] = 1
dp2 = [0]*(n+5)
for i in range(1,n+1):
dp[i] = (dp[i]+dp2[i]+dp2[i-1])%mod
dp2[i] = (dp2[i]+dp2[i-1])%mod
for l,r in K:
dp2[min(i+l,n+2)] += dp[i]
dp2[min(i+l,n+2)] %= mod
dp2[min(i+r+1,n+2)] -= dp[i]
dp2[min(i+r+1,n+2)] %= mod
print((dp[n]%mod))
| mod = 998244353
n,k = list(map(int,input().split()))
K = [list(map(int,input().split())) for i in range(k)]
dp = [0]*(n+1)
dp[0] = 1
dp2 = [0]*(n+1)
for i in range(n):
dp2[i] = (dp2[i]+dp2[i-1])%mod
dp[i] = (dp[i]+dp2[i])%mod
for l,r in K:
dp2[min(i+l,n)] = (dp2[min(i+l,n)]+dp[i])%mod
dp2[min(i+r+1,n)] = (dp2[min(i+r+1,n)]-dp[i])%mod
print((dp[n-1]%mod))
| p02549 |
n,k=list(map(int,input().split()))
dp=[0 for i in range(n+1)]
dp[1]=1
accum=[0 for i in range(n+1)]
accum[1]=1
s=[]
for i in range(k):
x,y=list(map(int,input().split()))
s.append([x,y])
for i in range(2,n+1):
for j in s:
l,r=j
tmpl=i-r
tmpr=i-l
if(tmpl<1):
tmpl=1
if(tmpr>=i):
tmpr=i-1
if(tmpr<0):
continue
dp[i]+=accum[tmpr]-accum[tmpl-1]
accum[i]=dp[i]+accum[i-1]
print((dp[n]%998244353)) | n,k=list(map(int,input().split()))
dp=[0 for i in range(n+1)]
dp[1]=1
accum=[0 for i in range(n+1)]
accum[1]=1
s=[]
for i in range(k):
x,y=list(map(int,input().split()))
s.append([x,y])
for i in range(2,n+1):
for j in s:
l,r=j
tmpl=i-r
tmpr=i-l
if(tmpl<1):
tmpl=1
if(tmpr>=i):
tmpr=i-1
if(tmpr<0):
continue
dp[i]+=accum[tmpr]-accum[tmpl-1]
dp[i]%=998244353
accum[i]=dp[i]+accum[i-1]
accum[i]%=998244353
print((dp[n]%998244353)) | p02549 |
N, K = list(map(int, input().split()))
L = [0] * K
R = [0] * K
for i in range(0, K):
L[i], R[i] = list(map(int, input().split()))
moves = [0] * N
moves[0] = 1
rui_wa = [0] * N
rui_wa[0] = 1
for i in range(1, N):
for j in range(0, K):
l = max(i - L[j], 0)
r = max(i - R[j], 0)
if i - L[j] < 0:
continue
moves[i] += rui_wa[l] - rui_wa[r - 1]
rui_wa[i] = moves[i] + rui_wa[i - 1]
print((moves[N - 1] % 998244353))
| N, K = list(map(int, input().split()))
L = [0] * K
R = [0] * K
for i in range(0, K):
L[i], R[i] = list(map(int, input().split()))
moves = [0] * N
moves[0] = 1
rui_wa = [0] * N
rui_wa[0] = 1
for i in range(1, N):
for j in range(0, K):
l = max(i - L[j], 0)
r = max(i - R[j], 0)
if i - L[j] < 0:
continue
moves[i] += (rui_wa[l] - rui_wa[r - 1]) % 998244353
rui_wa[i] = (moves[i] + rui_wa[i - 1]) % 998244353
print((moves[N - 1] % 998244353))
| p02549 |
import sys
import math
def input():
return sys.stdin.readline().rstrip()
def main():
N, K = list(map(int, input().split()))
L = [[] for _ in range(K)]
for t in range(K):
l, r = list(map(int, input().split()))
for j in range(l, r + 1):
L[t].append(j)
lc = [0] * K
mod = 998244353
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1,N+1):
for k in range(K):
CL =L[k]
if len(CL)==1:
lc[k]=dp[i-CL[0]]
else:
if CL[-1] > i:
lc[k] = lc[k] +dp[i-L[k][0]]
else:
lc[k] =( lc[k] + dp[i - L[k][0]] - dp[i - L[k][-1]-1] )%mod
dp[i] += lc[k]
print((dp[N - 1]%mod))
if __name__ == "__main__":
main()
# \n
| import sys
import math
def input():
return sys.stdin.readline().rstrip()
def main():
N, K = list(map(int, input().split()))
L = [[] for _ in range(K)]
for t in range(K):
l, r = list(map(int, input().split()))
for j in range(l, r + 1):
L[t].append(j)
lc = [0] * K
mod = 998244353
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1,N+1):
for k in range(K):
CL =L[k]
if len(CL)==1:
lc[k]=dp[i-CL[0]] %mod
else:
if CL[-1] > i:
lc[k] = lc[k] %mod +dp[i-L[k][0]] %mod
else:
lc[k] =( lc[k] + dp[i - L[k][0]] - dp[i - L[k][-1]-1] )%mod
dp[i] += lc[k]
print((dp[N - 1]%mod))
if __name__ == "__main__":
main()
# \n
| p02549 |
mod = 998244353
N,K = list(map(int,input().split()))
move = [list(map(int,input().split())) for _ in range(K)]
dp = [0]*(N+1)
dp_sum = [0]*(N+1)
dp[1] = dp_sum[1] = 1
for i in range(2,N+1):
for l,r in move:
if 0<i-l:
dp[i] += dp_sum[i-l]
if 0<i-r-1:
dp[i] -= dp_sum[i-r-1]
dp_sum[i] = dp_sum[i-1] + dp[i]
print((dp[-1]%mod)) | mod = 998244353
N,K = list(map(int,input().split()))
move = [list(map(int,input().split())) for _ in range(K)]
dp = [0]*(N+1)
dp_sum = [0]*(N+1)
dp[1] = dp_sum[1] = 1
for i in range(2,N+1):
for l,r in move:
if 0<i-l:
dp[i] += dp_sum[i-l]
if 0<i-r-1:
dp[i] -= dp_sum[i-r-1]
dp[i] %= mod
dp_sum[i] = dp_sum[i-1] + dp[i]
print((dp[-1]%mod))
| p02549 |
import sys
import re
import queue
import collections
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(eval(input()))
def i_map(): return list(map(int, input().split()))
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return eval(input())
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []
def main():
N,K= i_map()
L = []
R = []
for i in range(0,K):
tmpL,tmpR = i_map()
L.append(tmpL)
R.append(tmpR)
a = []
a.append(0)
a.append(-1)
for i in range(2,3*N):
a.append(0)
f = []
f.append(1)
for i in range(0,N):
for j in range(0,K):
a[i+L[j]] += f[i]
a[i+R[j]+1] += -f[i]
f.append(f[i]+a[i+1])
print((f[N-1]%998244353))
return
if __name__ == '__main__':
main() | import sys
import re
import queue
import collections
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline
def i_input(): return int(eval(input()))
def i_map(): return list(map(int, input().split()))
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return eval(input())
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []
def main():
N,K= i_map()
m = 998244353
L = []
R = []
for i in range(0,K):
tmpL,tmpR = i_map()
L.append(tmpL)
R.append(tmpR)
a = []
a.append(0)
a.append(-1)
for i in range(2,3*N):
a.append(0)
f = []
f.append(1)
for i in range(0,N):
for j in range(0,K):
a[i+L[j]] += f[i]
a[i+R[j]+1] += -f[i]
f.append((f[i]+a[i+1])%m)
print((f[N-1]%m))
return
if __name__ == '__main__':
main() | p02549 |
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
MOD = 998244353
dic = []
for l, r in LR:
tmp = [x for x in range(l, r+1)]
dic += tmp
dic.sort()
dp = [0]*(N+1)
dp[1] = 1
n = len(dic)
cnt = 0
t = []
for i in range(2, N+1):
tmp = i-1
while cnt < n:
if dic[cnt] <= tmp:
t.append(dic[cnt])
cnt += 1
else:
break
for s in t:
dp[i] += dp[i-s]
dp[i] %= MOD
print((dp[-1]))
| def main():
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
MOD = 998244353
dp = [0]*(N+1)
S = [0]*(N+1)
dp[1] = 1
S[1] = 1
for i in range(2, N+1):
for l, r in LR:
if i-l < 0:
continue
else:
dp[i] += S[i-l] - S[max(i-r-1, 0)]
dp[i] %= MOD
S[i] = S[i-1] + dp[i]
print((dp[-1]%MOD))
if __name__ == '__main__':
main()
| p02549 |
MOD = 998244353
class BIT:
def __init__(self, n, init=None):
self.size = n
if init is None:
self.v = [0] * (n + 1) # don't use bit[0]
else:
self.v = [0] + init
for i in range(1, n):
if i + (i & -i) <= n: self.v[i + (i & -i)] += self.v[i]
def sum(self, i):
'''
Calculate a[1] + ... + a[i]
'''
S = 0
while i > 0:
S += self.v[i]
i -= i & -i
return S
def modsum(self, i, mod):
'''
Calculate a[1] + ... + a[i]
'''
S = 0
while i > 0:
S += self.v[i]
S %= mod
i -= i & -i
return S
def add(self, i, x):
'''
set a[i] to be a[i] + x
'''
assert i > 0
while i <= self.size:
self.v[i] += x
i += i & -i
N, K = list(map(int, input().split()))
segments = [tuple(map(int, input().split())) for _ in range(K)]
bit = BIT(N + 1)
bit.v[1] = 1
for i in range(1, N + 1):
temp = bit.sum(i)
for s, t in segments:
if i + s <= N:
bit.add(i + s, temp)
bit.add(min(i + t + 1, N + 1), -temp)
print((bit.modsum(N, MOD))) | MOD = 998244353
N, K = list(map(int, input().split()))
segments = [tuple(map(int, input().split())) for _ in range(K)]
dp = [0] * (2 * N + 1)
for i in range(N):
for s, t in segments:
t += 1
dp[i + s] += dp[i] if i != 0 else 1
dp[i + t] -= dp[i] if i != 0 else 1
dp[i + 1] += dp[i]
dp[i + 1] %= MOD
print((dp[N - 1])) | p02549 |
N, K = (int(i) for i in input().split())
l, r = [0]*K, [0]*K
for k in range(K):
l[k], r[k] = (int(x) for x in input().split())
# dp : マスiまで移動する方法のパターン数
# TLE
'''
import numpy as np
dp = [0]*N
dp[0] = 1
for i in range(N):
for k in range(K):
for j in range(l[k], r[k]+1):
if (i+j < N):
dp[i+j] = dp[i+j] + dp[i]
if j == r[k]:
print(i, (l[k], r[k]), dp, np.diff(dp))
print(dp[-1]%998244353)
'''
# dp : マスiまで移動する方法のパターン数
# dps : dp[i] と dp[i+1] の 差
dp = [0]*N
dps = [0]*(N-1)
dp[0] = 1
dps[0] = -1
for i in range(N-1):
for k in range(K):
if i + l[k] - 1 < (N - 1):
dps[i + l[k] - 1] += dp[i]
if i + r[k] < (N - 1):
dps[i + r[k] ] -= dp[i]
#print(i, (l[k], r[k]), dp, dps)
dp[i+1] = dps[i] + dp[i]
print((dp[-1]%998244353)) | N, K = (int(i) for i in input().split())
l, r = [0]*K, [0]*K
for k in range(K):
l[k], r[k] = (int(x) for x in input().split())
# dp : マスiまで移動する方法のパターン数
# TLE
'''
import numpy as np
dp = [0]*N
dp[0] = 1
for i in range(N):
for k in range(K):
for j in range(l[k], r[k]+1):
if (i+j < N):
dp[i+j] = dp[i+j] + dp[i]
if j == r[k]:
print(i, (l[k], r[k]), dp, np.diff(dp))
print(dp[-1]%998244353)
'''
# dp : マスiまで移動する方法のパターン数
# dps : dp[i] と dp[i+1] の 差
dp = [0]*N
dps = [0]*(N-1)
dp[0] = 1
dps[0] = -1
for i in range(N-1):
for k in range(K):
if i + l[k] - 1 < (N - 1):
dps[i + l[k] - 1] += dp[i]
if i + r[k] < (N - 1):
dps[i + r[k] ] -= dp[i]
#print(i, (l[k], r[k]), dp, dps)
dp[i+1] = (dps[i] + dp[i])%998244353
print((dp[-1]%998244353)) | p02549 |
n,k=list(map(int,input().split()))
ans=[0 for _ in range(n*3)]
ans[1]=1
idou=[]
for _ in range(k):
a=list(map(int,input().split()))
idou.append(a)
mod=998244353
rui=[0 for _ in range(n+1)]
rui[1]=1
for i in range(2,n+1):
for g in idou:
x,y=g
left=max(0,i-y-1)
right=max(0,i-x)
ans[i]+=rui[right]-rui[left]
rui[i]+=((rui[i-1]+ans[i]))
print((ans[n]%mod))
| n,k=list(map(int,input().split()))
ans=[0 for _ in range(n*3)]
ans[1]=1
idou=[]
for _ in range(k):
a=list(map(int,input().split()))
idou.append(a)
mod=998244353
rui=[0 for _ in range(n+1)]
rui[1]=1
for i in range(2,n+1):
for g in idou:
x,y=g
left=max(0,i-y-1)
right=max(0,i-x)
ans[i]+=(rui[right]-rui[left])%mod
rui[i]+=((rui[i-1]+ans[i]))%mod
print((ans[n]%mod))
| p02549 |
#editorial
n,k=list(map(int,input().split()))
*lr,=[tuple(map(int, input().split())) for _ in range(k)]
res =[0]*(2*n+3)
##############
diff=[0]*(2*n+3)
######
#res[0]=1
diff[0]=1
diff[1]=-1
mod=998244353
for i in range(n+1):
res[i]=res[i-1]+diff[i]
for li,ri in lr:
diff[i+li]+=res[i]
diff[i+ri+1]-=res[i]
#print(res[:n+1])
#print((diff[:n+1]))
print((res[n-1]%mod))
#print(res[:n+1])
#print((diff[:n+1]))
| #editorial
n,k=list(map(int,input().split()))
*lr,=[tuple(map(int, input().split())) for _ in range(k)]
res =[0]*(2*n+3)
##############
diff=[0]*(2*n+3)
######
#res[0]=1
diff[0]=1
diff[1]=-1
mod=998244353
for i in range(n+1):
res[i]=res[i-1]+diff[i]
res[i]%=mod
diff[i]%=mod
for li,ri in lr:
diff[i+li]+=res[i]
diff[i+ri+1]-=res[i]
#print(res[:n+1])
#print((diff[:n+1]))
print((res[n-1]%mod))
#print(res[:n+1])
#print((diff[:n+1]))
| p02549 |
n, k = list(map(int, input().split()))
F = [0]*(n+2) # [l,r+1): 1<=[l]<[r+1]<=n+1
for _ in range(k):
l, r = list(map(int, input().split()))
F[l] += 1
F[r+1] += -1
# print(F)
S = []
for i in range(n+1): # i:[0, n]
if F[i] > 0: S.append(i)
F[i+1] += F[i]
# print(F)
# print(n,k)
# print(S)
MOD = 998244353
dp = [0]*(n+1) # [0,n]
dp[1] = 1
for i in range(1, n+1): # i:[1,n]
for s in S:
if i + s <= n:
# print('s {} i {} n {}'.format(s,i,n))
dp[i + s] += dp[i]
dp[i + s] %= MOD
# print(dp)
print(((dp[n] + MOD) % MOD))
| n, k = list(map(int, input().split()))
LR = []
for _ in range(k):
l, r = list(map(int, input().split()))
LR.append([l, r+1])
MOD = 998244353
dp = [0]*(n+1) # [0,n]
dp[0] = 1
dp[1] = -1
for i in range(n): # i:[0,n-1]
if i > 0: dp[i] += dp[i-1]
for j in range(k):
l, r = LR[j]
if i+l < n:
dp[i+l] += dp[i]
dp[i+l] %= MOD
if i+r < n:
dp[i+r] -= dp[i]
dp[i+r] %= MOD
print(((dp[n-1] + MOD) % MOD))
| p02549 |
n,k = list(map(int,input().split()))
sec = []
for i in range(k):
l,r = list(map(int,input().split()))
sec.append([l,r])
dp = [0]*(n+1)
dp[0],dp[1] = 0,1
cumsum = [0]*(n+1)
cumsum[1] = 1
for i in range(2,n+1):
for l,r in sec:
if i>l:
dp[i] += cumsum[i-l]-cumsum[max(0,i-r-1)]
cumsum[i] = dp[i]+cumsum[i-1]
print((dp[n]%998244353)) | n,k = list(map(int,input().split()))
sec = []
for i in range(k):
l,r = list(map(int,input().split()))
sec.append([l,r])
mod = 998244353
dp = [0]*(n+1)
dp[0],dp[1] = 0,1
cumsum = [0]*(n+1)
cumsum[1] = 1
for i in range(2,n+1):
for l,r in sec:
if i>l:
dp[i] += cumsum[i-l]-cumsum[max(0,i-r-1)]
cumsum[i] = (dp[i]+cumsum[i-1])%mod
print((dp[n]%mod)) | p02549 |
from collections import deque
MOD = 998244353
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
S = list()
for lr in LR:
for i in range(lr[0], lr[1]+1):
S.append(i)
dp = [0]*(N+1) # dp[i] : iに行く方法
dp[1] = 1
memo1 = deque()
memo2 = deque()
for i in range(1, N+1):
# for s in S:
# if i + s <= N:
# dp[i + s] += dp[i]
# dp[i + s] %= MOD
while(len(memo1)):
# l = m[1]
# r = m[2]
m = memo1.popleft()
if m[1] <= i and i <= m[2]:
dp[i] += m[0]
dp[i] %= MOD
if not(m[2] < i):
memo2.append(m)
while(len(memo2)):
tmp = memo2.popleft()
memo1.append(tmp)
for lr in LR:
memo1.append([dp[i], lr[0] + i, lr[1] + i])
print((dp[N])) | MOD = 998244353
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
dp = [0]*(N+1)
acc = [0]*(N+1) # acc[i] = dp[1] + ... dp[i]
dp[1] = 1
acc[1] = 1
for i in range(2, N+1):
for lr in LR:
l = lr[0]
r = lr[1]
dp[i] += (acc[max(0, i - l)] - acc[max(0, i - r - 1)] + MOD)
dp[i] %= MOD
acc[i] = (acc[i-1] + dp[i]) % MOD
print((dp[N]))
# print(acc)
# print(dp[N]) | p02549 |
n, k = list(map(int, input().split()))
s = []
for i in range(k):
a, b = list(map(int, input().split()))
for j in range(a, b+1):
s.append(j)
s = set(s)
dp = [0]*(n+1)
dp[1] = 1
mod = 998244353
for i in range(1, n+1):
for ss in s:
if i+ss <= n:
dp[i+ss] += dp[i]
dp[i+ss] %= mod
print((dp[-1]))
| n, k = list(map(int, input().split()))
s = []
for i in range(k):
a, b = list(map(int, input().split()))
s.append((a, b))
dp = [0]*(n+1)
v = 0
mod = 998244353
for i in range(1, n+1):
if i == 1:
for l, r in s:
if i+l <= n:
dp[i+l] += 1
if i+r+1 <= n:
dp[i+r+1] -= 1
else:
v += dp[i]
v %= mod
for l, r in s:
if i+l <= n:
dp[i+l] += v
if i+r+1 <= n:
dp[i+r+1] -= v
print((v % mod))
| p02549 |
n, k = list(map(int, input().split()))
l = []
r = []
for i in range(k):
a, b = list(map(int, input().split()))
l.append(a)
r.append(b)
mod = 998244353
dp = [0] * (n + 1)
#１マス目の行き方は１通り
dp[1] = 1
dpsum = [0] * (n + 1)
dpsum[1] = 1
for i in range(2, n + 1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri < 0:
continue
li = max(1, li)
dp[i] += dpsum[ri] - dpsum[li - 1]
dpsum[i] = dpsum[i - 1] + dp[i]
print((dp[n] % mod))
| n, k = list(map(int, input().split()))
l = []
r = []
for i in range(k):
a, b = list(map(int, input().split()))
l.append(a)
r.append(b)
mod = 998244353
dp = [0] * (n + 1)
#１マス目の行き方は１通り
dp[1] = 1
dpsum = [0] * (n + 1)
dpsum[1] = 1
for i in range(2, n + 1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri < 0:
continue
li = max(1, li)
dp[i] += (dpsum[ri] - dpsum[li - 1]) % mod
dpsum[i] = dpsum[i - 1] + dp[i]
print((dp[n] % mod))
| p02549 |
n, k = list(map(int, input().split()))
s = []
mod = 998244353
for i in range(k):
l, r = list(map(int, input().split()))
s.append([l, r])
dp = [0 for _ in range(n+1)]
dp[1] = 1
dpsum = [0 for _ in range(n+1)]
dpsum[1] = 1
for i in range(2,n+1):
for l, r in s:
li = max(i-r,1)
ri = max(i-l,0)
dp[i] += dpsum[ri] - dpsum[li-1]
dpsum[i] = dpsum[i-1] + dp[i]
print((dp[n]%mod)) | n, k = list(map(int, input().split()))
s = []
mod = 998244353
for i in range(k):
l, r = list(map(int, input().split()))
s.append([l, r])
dp = [0 for _ in range(n+1)]
dp[1] = 1
dpsum = [0 for _ in range(n+1)]
dpsum[1] = 1
for i in range(2,n+1):
for l, r in s:
li = max(i-r,1)
ri = max(i-l,0)
dp[i] += (dpsum[ri] - dpsum[li-1])%mod
dpsum[i] = (dpsum[i-1] + dp[i])%mod
print((dp[n]%mod)) | p02549 |
n,k=list(map(int,input().split()))
mod=998244353
r=[0]*k
l=[0]*k
for _ in range(k):
l_,r_=list(map(int,input().split()))
l[_]=l_
r[_]=r_
dp=[0]*n
dp[0]=1
dpsum=[0]*n
dpsum[0]=1
for i in range(1,n):
for j in range(k):
li=i-r[j]
ri=i-l[j]
if ri>=0:
li=max(li,0)
dp[i]+=dpsum[ri]-dpsum[li-1]
dpsum[i]=dpsum[i-1]+dp[i]
print((dp[n-1]%mod)) | n,k=list(map(int,input().split()))
mod=998244353
s=set()
for _ in range(k):
l,r=list(map(int,input().split()))
for j in range(l,r+1):
s.add(j)
m=len(s)
dp=[0]*n
dp[0]=1
for i in range(1,n):
for j in s:
if i-j>=0:
dp[i]+=dp[i-j]
print((dp[n-1]%mod))
| p02549 |
n,k=list(map(int,input().split()))
mod=998244353
s=set()
for _ in range(k):
l,r=list(map(int,input().split()))
for j in range(l,r+1):
s.add(j)
m=len(s)
dp=[0]*n
dp[0]=1
for i in range(1,n):
for j in s:
if i-j>=0:
dp[i]+=dp[i-j]
print((dp[n-1]%mod))
| n,k=list(map(int,input().split()))
mod=998244353
l=[0]*n
r=[0]*n
for i in range(k):
l[i],r[i]=list(map(int,input().split()))
dp=[0]*(n+10)
dp[0]=1
sumdp=[0]*(n+10)
sumdp[1]=1
for i in range(1,n):
for j in range(k):
li=max(0,i-r[j])
ri=max(0,i-l[j]+1)
dp[i]+=sumdp[ri]-sumdp[li]
sumdp[i+1]=(sumdp[i]+dp[i])%mod
print((dp[n-1]%mod)) | p02549 |
N,K = list(map(int,input().split()))
MOD = 998244353
interval = []
for i in range(K):
L,R = list(map(int,input().split()))
for j in range(L,R+1):
interval.append(j)
dp = [0]*N
dp[0] = 1
for i in range(N-1):
for j in interval:
if j <= N-1 - i:
dp[i+j] += dp[i]
dp[i+j] %= MOD
print((dp[N-1])) | N,K = list(map(int,input().split()))
MOD = 998244353
interval = []
for i in range(K):
intv = [int(x) for x in input().split()]
interval.append(intv)
dp = [0]*N
diff = [0]*(N-1)
dp[0] = 1
diff[0] = -1
for i in range(N-1):
for L,R in interval:
if L <= N-1 - i:
diff[i+L-1] += dp[i]
if R+1 <= N-1 - i:
diff[i+R] -= dp[i]
dp[i+1] = dp[i] + diff[i]
dp[i+1] %= MOD
print((dp[N-1])) | p02549 |
import sys
def input(): return sys.stdin.readline().rstrip()
N, K = list(map(int, input().split()))
L = []
for i in range(K):
l, r = list(map(int, input().split()))
L.append((l,r))
L.sort()
dp = [0] * (N+1)
dp[1] = 1
for i in range(2,N+1):
count = 0
for l,r in L:
if l >= i:
break
elif l < i and i - r > 1:
count += dp[i-l] - dp[i-r-1]
else:
count += dp[i-l]
dp[i] = dp[i-1] + count
print(((dp[N] - dp[N-1])% 998244353)) | import sys
def input(): return sys.stdin.readline().rstrip()
mod = 998244353
N, K = list(map(int, input().split()))
L = []
for i in range(K):
l, r = list(map(int, input().split()))
L.append((l,r))
L.sort()
dp = [0] * (N+1)
dp[1] = 1
for i in range(2,N+1):
count = 0
for l,r in L:
if l >= i:
break
elif l < i and i - r > 1:
count += dp[i-l] - dp[i-r-1]
else:
count += dp[i-l]
dp[i] = (dp[i-1] + count) % mod
print(((dp[N] - dp[N-1])% mod)) | p02549 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mat = lambda x, y, v: [[v]*y for _ in range(x)]
ten = lambda x, y, z, v: [mat(y, z, v) for _ in range(x)]
mod = 1000000007
sys.setrecursionlimit(1000000)
mod = 998244353
N, K = rl()
lr = []
for i in range(K):
l, r = rl()
lr.append((l,r))
lr.sort()
dp = [0] * (N+1)
dp[1] = 1
dp[2] = -1
ans = 0
s = 0
flags = [1] * K
for i in range(1, N+1):
s += dp[i]
for k in range(K):
if flags[k] == 0:
break
l, r = lr[k]
if i+l <= N:
dp[i+l] += s
if i+r+1 <= N:
dp[i+r+1] -= s
else:
ans += s
ans %= mod
break
else:
flags[k] = 0
break
print(ans)
| import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mat = lambda x, y, v: [[v]*y for _ in range(x)]
ten = lambda x, y, z, v: [mat(y, z, v) for _ in range(x)]
mod = 1000000007
sys.setrecursionlimit(1000000)
mod = 998244353
N, K = rl()
lr = []
for i in range(K):
l, r = rl()
lr.append((l,r))
lr.sort()
dp = [0] * (N+1)
dp[1] = 1
dp[2] = -1
ans = 0
s = 0
flags = [1] * K
for i in range(1, N+1):
s += dp[i]
s %= mod
for k in range(K):
if flags[k] == 0:
break
l, r = lr[k]
if i+l <= N:
dp[i+l] += s
if i+r+1 <= N:
dp[i+r+1] -= s
else:
ans += s
ans %= mod
break
else:
flags[k] = 0
break
print(ans)
| p02549 |
n,k = list(map(int,input().split()))
mod = 998244353
s = []
for i in range(k):
l,r = list(map(int,input().split()))
for i in range(l,r+1):
s.append(i)
s.sort()
# print(s)
dp = [0 for i in range(n+1)]
dp[1] = 1
for i in range(2,n+1):
for j in s:
if i-j >= 1:
dp[i] += dp[i-j]
# print(dp)
print((dp[n] % mod)) | n,k = list(map(int,input().split()))
mod = 998244353
l,r = [0]*k,[0]*k
for i in range(k):
ll,rr = list(map(int,input().split()))
l[i],r[i] = ll,rr
dp = [0]*(n+1)
dpsum = [0]*(n+1)
dp[1], dpsum[1] = 1,1
for i in range(2,n+1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri < 0:
continue
dp[i] += dpsum[ri] - dpsum[li-1]
dp[i] %= mod
dpsum[i] = dpsum[i-1] + dp[i]
print((dp[n])) | p02549 |
import sys
input = sys.stdin.readline
m = 998244353
def main():
n,k = list(map(int,input().split()))
l,r = [],[]
for _ in range(k):
l_, r_ = list(map(int,input().split()))
l.append(l_)
r.append(r_)
dp = [0]*(n+1)
dp[1] = 1
dpsum = [0]*(n+1)
dpsum[1] = 1
for i in range(2,n+1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri < 0:
continue
li = max(li,1)
dp[i] += dpsum[ri] - dpsum[li-1]
dpsum[i] = dpsum[i-1]+dp[i]
print((dp[n]%m))
main() | m = 998244353
def main():
n,k = list(map(int,input().split()))
l,r = [],[]
for _ in range(k):
l_, r_ = list(map(int,input().split()))
l.append(l_)
r.append(r_)
dp = [0]*(n+1)
dp[1] = 1
dpsum = [0]*(n+1)
dpsum[1] = 1
for i in range(2,n+1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri < 0:
continue
li = max(li,1)
dp[i] += dpsum[ri] - dpsum[li-1]
dpsum[i] = (dpsum[i-1]+dp[i])%m
print((dp[n]%m))
main() | p02549 |
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
mod = 998244353
n, k = list(map(int, input().split()))
s = set()
for _ in range(k):
l, r = list(map(int, input().split()))
for i in range(l, r + 1):
s.add(i)
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
for j in range(i):
if i - j in s:
dp[i] += dp[j]
dp[i] %= mod
print((dp[-2]))
| import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
mod = 998244353
n, k = list(map(int, input().split()))
l = []
r = []
for _ in range(k):
l_, r_ = list(map(int, input().split()))
l.append(l_)
r.append(r_)
dp = [0] * (n + 1)
dp_csum = [0] * (n + 1)
dp[1] = 1
dp_csum[1] = 1
for i in range(2, n + 1):
for j in range(k):
left = i - r[j]
right = i - l[j]
if right >= 1:
dp[i] += dp_csum[right] - dp_csum[max(left, 1) - 1]
dp[i] %= mod
dp_csum[i] = dp_csum[i - 1] + dp[i]
dp_csum[i] %= mod
print((dp[-1])) | p02549 |
P=998244353
N,K=list(map(int,input().split()))
LR=[]
for _ in range(K):
l,r=list(map(int,input().split()))
LR+=list(range(l,r+1))
LR=list(set(LR))
c=[0]*N
c[0]=1
for k in range(N):
S=[x for x in LR if x<=k]
while len(S):
c[k]+=c[k-S[-1]]%P
S.pop()
print((c[-1]%P)) | P=998244353
N,K=list(map(int, input().split()))
LR=[list(map(int, input().split())) for _ in range(K)]
s=[0 for _ in range(N+1)]
s[1]=1
for i in range(1,N):
s[i+1] = s[i]
for l,r in LR:
s[i+1]+=(s[max(0,i-l+1)]-s[max(0,i-r)])%P
s[i+1]%=P
print(((s[N]-s[N-1])%P)) | p02549 |
N,K=list(map(int,input().split()))
L=[]
for i in range(K):
l,r=list(map(int,input().split()))
L.append([l,r+1])
L.sort()
mod=998244353
A=[0 for i in range(N+1)]
A[1]=1
for i in range(N+1):
if A[i]>0:
A[i]%=mod
for l,r in L:
for n in range(l+i,r+i):
if n<=N:
A[n]+=A[i]
else:
break
print((A[N]%mod)) | N,k=list(map(int,input().split()))
L=[0 for i in range(2)]
K=[]
for i in range(k):
l,r=list(map(int,input().split()))
K.append([l,r])
mod=998244353
L[1]=1
R=[0,1]
for i in range(2,N+1):
cnt=0
for l,r in K:
cnt+=R[max(0,i-l)]
cnt-=R[max(0,i-(r+1))]
cnt%=mod
L.append(cnt)
R.append(R[-1]+cnt)
print((L[-1]%mod))
#print(R) | p02549 |
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 19 20:18:10 2020
@author: liang
"""
#D
N, K = list(map(int, input().split()))
areas = list()
for i in range(K):
l, r = list(map(int,input().split()))
areas.append((l,r))
areas_sum = [0] * N
d = [0] * N
d[0] = 1
for i in range(N):
for j in range(K):
l, r = areas[j]
if i-l >= 0:
areas_sum[j] += d[i-l]
if i-r-1 >= 0:
areas_sum[j] -= d[i-r-1]
d[i] += sum(areas_sum)
d[i] %= 998244353
#print(d)
ans = d[N-1]
print(ans) | # -*- coding: utf-8 -*-
"""
Created on Sat Sep 19 20:18:10 2020
@author: liang
"""
#D
N, K = list(map(int, input().split()))
areas = list()
for i in range(K):
l, r = list(map(int,input().split()))
areas.append((l,r))
#areas_sum = [0] * N
tmp = 0
d = [0] * N
#check = [0] * N
#check[0] = 1
d[0] = 1
for i in range(N):
for j in range(K):
l, r = areas[j]
if i-l >= 0:
#areas_sum[j] += d[i-l]
tmp += d[i-l]
if i-r-1 >= 0:
#areas_sum[j] -= d[i-r-1]
tmp -= d[i-r-1]
d[i] += tmp
#check[i] += tmp
d[i] %= 998244353
tmp %= 998244353
#t.append(tmp)
#print(d)
#print(check)
ans = d[N-1]
print(ans)
#print(tmp) | p02549 |
N, K = list(map(int, input().split()))
S = []
for j in range(K):
LRj = list(map(int, input().split()))
for s in range(LRj[0], LRj[1] + 1):
S.append(s)
m = 998244353
# print(S)
dp = [0] * N
dp[0] = 1
for i in range(1, N):
for s in S:
if s <= i:
# print(i, i-s)
dp[i] += dp[i - s] % m
dp[i] %= m
ans = dp[N - 1]
print(ans) | N, K = list(map(int, input().split()))
S = []
for j in range(K):
S.append(list(map(int, input().split())))
m = 998244353
# print(S)
dp = [0] * N
dp[0] = 1
sum_of_region = [0] * K
for i in range(1, N):
for j in range(K):
if i - S[j][0] >= 0:
sum_of_region[j] += dp[i - S[j][0]]
if i - S[j][1] - 1 >= 0:
sum_of_region[j] -= dp[i - S[j][1] - 1]
dp[i] += sum_of_region[j] % m
dp[i] %= m
# print(i, dp, sum_of_region)
ans = dp[N - 1]
print(ans)
| p02549 |
N, K = list(map(int, input().split()))
dp = [0] * N
dp[0] = 1
dp_sum = [0] * N
L = [0] * K
R = [0] * K
mod = 998244353
for i in range(K):
l, r = list(map(int, input().split()))
L[i] = l
R[i] = r
for i in range(1, N):
# マスiにたどり着くためのパターン数を数える
cnt = 0
for j in range(K):
start = max(0, i - R[j])
end = i - L[j]
if end < 0:
continue
cnt += sum(dp[start:end+1]) % mod
cnt %= mod
dp[i] = cnt
print((dp[N - 1]))
| N, K = list(map(int, input().split()))
dp = [0] * N
dp[0] = 1
dp_sum = [0] * N
dp_sum[0] = 1
L = [0] * K
R = [0] * K
mod = 998244353
for i in range(K):
l, r = list(map(int, input().split()))
L[i] = l
R[i] = r
for i in range(1, N):
# マスiにたどり着くためのパターン数を数える
cnt = 0
for j in range(K):
start = max(0, i - R[j])
end = i - L[j]
cnt += (dp_sum[end] - dp_sum[start - 1]) % mod
cnt %= mod
dp[i] = cnt
dp_sum[i] = dp_sum[i - 1] + cnt
print((dp[N - 1]))
| p02549 |
n,k=[int(c) for c in input().split()]
MOD = 998244353
segs = set()
for _ in range(k):
a,b=[int(c) for c in input().split()]
for i in range(a,b+1):
segs.add(i)
dp =[0 for i in range(n)]
dp[0] = 1
# print(segs)
for i in range(n-1):
if dp[i] != 0:
for j in segs:
if i + j < n:
dp[i+j] = dp[i+j] + dp[i]
dp[i+j]%=MOD
# print(dp)
print((dp[-1]))
| n,k=[int(c) for c in input().split()]
MOD = 998244353
segs = []
for _ in range(k):
a,b=[int(c) for c in input().split()]
segs.append((a,b))
dp=[0 for i in range(n+5)]
dp[0] = 1
for i in range(n):
# dp[i] = dp[i] + dp[i-1]
if dp[i] < 0:
dp[i]+=MOD
for a,b in segs:
if i+a <=n:
dp[i+a]+=dp[i]
if i+b+1 <= n:
dp[i+b+1]-=dp[i]
dp[i]%=MOD
if i !=0:
dp[i+1] = dp[i+1]+dp[i]
print((dp[n-1]%MOD))
| p02549 |
N, K = list(map(int, input().split()))
dp = [0] * (2 * 10 ** 5 + 1)
S = set()
for i in range(K):
l, r = list(map(int, input().split()))
for v in range(l, r + 1):
S.add(v)
dp[1] = 1
MOD = 998244353
for i in range(1, N):
for v in S:
if i + v <= N:
dp[i + v] += dp[i]
dp[i + v] %= MOD
print((dp[N]))
| N, K = list(map(int, input().split()))
W = [0] * (N + 1)
W[1] = 1
R = []
for i in range(K):
l, r = list(map(int, input().split()))
R.append((l, r))
MOD = 998244353
for i in range(1, N):
for l, r in R:
a = max(i - r, 0)
b = i - l
if b < 0:
continue
W[i + 1] += (W[b + 1] - W[a])
W[i + 1] %= MOD
W[i + 1] += W[i]
print((W[N] - W[N - 1]))
| p02549 |
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
dp = [0] * (N + 1)
dpsum = [0] * (N + 1)
dp[1] = 1
dpsum[1] = 1
for i in range(2, N + 1):
for j in range(K):
li = max(i - LR[j][1], 1)
ri = i - LR[j][0]
if ri < 0:
continue
dp[i] += dpsum[ri] - dpsum[li - 1]
dpsum[i] = dpsum[i - 1] + dp[i]
print((dp[N] % 998244353))
| N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
mod = 998244353
dp = [0] * (N + 1)
dpsum = [0] * (N + 1)
dp[1] = 1
dpsum[1] = 1
for i in range(2, N + 1):
for j in range(K):
li = max(i - LR[j][1], 1)
ri = i - LR[j][0]
if ri < 0:
continue
dp[i] += dpsum[ri] - dpsum[li - 1]
dp[i] %= mod
dpsum[i] = dpsum[i - 1] + dp[i]
print((dp[N]))
| p02549 |
mod = 998244353
class FenwickTree:
def __init__(self, n, init_list=None):
self.n = n
self.data = [0] * n
if init_list:
assert n == len(init_list)
for i in range(n):
self.add(i, init_list[i])
def add(self, i, val):
assert 0 <= i < self.n
i += 1
while i <= self.n:
self.data[i - 1] = (val + self.data[i - 1]) % mod
i += i & -i #LSBを加算して上の層へ
def update(self, i, val):
self.add(i, val - self.sum(i, i+1))
def sum(self, l, r): #[l, r)
assert 0 <= l <= r <= self.n
if l != 0:
return (self.sum(0, r) - self.sum(0, l)) % mod
ret = 0
while r > 0:
ret = (ret + self.data[r - 1]) % mod
r -= r & -r #LSB減算して上の層へ
return ret
n, k = list(map(int, input().split()))
s = []
for _ in range(k):
l, r = list(map(int, input().split()))
s.append((l, r))
ft = FenwickTree(n)
ft.add(0, 1)
for i in range(1, n):
for l, r in s:
jl = i - l
jr = max(i - r, 0)
if jl < 0:
continue
ft.add(i, ft.sum(jr, jl+1) % mod)
print((ft.sum(n-1, n) % mod)) | mod = 998244353
n, k = list(map(int, input().split()))
s = []
for _ in range(k):
l, r = list(map(int, input().split()))
s.append((l, r))
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n+1):
for l, r in s:
jl = max(i - l, 0)
jr = max(i - r - 1, 0)
dp[i] = (dp[i] + dp[jl] - dp[jr]) % mod
dp[i] += dp[i-1]
print(((dp[n] - dp[n-1]) % mod))
| p02549 |
mod = 998244353
N, K = list(map(int,input().split()))
v = []
for _ in range(K):
L, R = list(map(int,input().split()))
# for d in range(L, R+1):
# moves.append(d)
v.append((L, R))
v.sort()
dp = [0] * N # マスi-1に到達するまでの操作列の個数
sdp = [0] * (N + 1) # dp[i]までの累積和
dp[0] = 1
sdp[1] = 1
for n in range(1, N):
for p in v:
left = max(0, n - p[1])
right = max(0, n - p[0]+1)
dp[n] += sdp[right] - sdp[left]
sdp[n+1] = sdp[n] + dp[n]
print((dp[-1] % mod)) | n, k = list(map(int, input().split()))
sec = [list(map(int, input().split())) for _ in range(k)]
sec.sort()
mod = 998244353
dp = [0] * n
dp[0] = 1
sum_dp = [0, 1]
for i in range(1, n):
for l, r in sec:
if i - l < 0:
break
elif i - r > 0:
dp[i] = ((dp[i] + sum_dp[i-l+1]) % mod - sum_dp[i-r]) % mod
else:
dp[i] = (dp[i] + sum_dp[i-l+1]) % mod
sum_dp.append((sum_dp[-1] + dp[i]) % mod)
print((dp[n-1]))
| p02549 |
n, k = list(map(int, input().split()))
m = 998244353
s = []
for i in range(k):
l, r = list(map(int, input().split()))
for j in range(l, r+1):
s.append(j)
dp = [0] * n
dp[0] = 1
for i in range(n):
for j in s:
ind = i-j
if ind >= 0:
dp[i] += dp[ind]
dp[i] %= 998244353
print((dp[n-1])) | n, k = list(map(int, input().split()))
m = 998244353
s = []
for i in range(k):
l, r = list(map(int, input().split()))
s.append((l, r))
dp = [0] * n
dp[0] = 1
totals = [0] * n
totals[0] = 1
for i in range(1, n):
thisTotal = 0
for l, r in s:
indL = i-l
if indL >= 0:
indR = max(0, i-r)
thisTotal += totals[indL] - totals[indR-1]
dp[i] = (thisTotal%m)
totals[i] = (totals[i-1] + thisTotal)%m
print((dp[n-1])) | p02549 |
root=[]
n,k = list(map(int,input().split()))
for i in range(k):
x,y = list(map(int,input().split()))
root.append([x,y])
toori=[0]*(2*10**5)+[0]*n+[0]*(2*10**5)
toori[2*10**5]=1
cum=[0]*k
for a,i in enumerate (root):
s=0
for j in range (i[0],i[1]+1):
s+=toori[2*10**5+1-j]
cum[a]=s
aaa=sum(cum)
toori[2*10**5+1]+=aaa
for now in range(2,n):#nowが今の場所
hueru=0
for a,i in enumerate (root):
hueru+=(toori[2*10**5+now-i[0]] - toori[2*10**5+now-1-i[1]])
aaa+=hueru
toori[2*10**5+now]+=aaa
toori[2*10**5+n-1]%=998244353
print((toori[2*10**5+n-1]%998244353))
| root=[]
n,k = list(map(int,input().split()))
for i in range(k):
x,y = list(map(int,input().split()))
root.append([x,y])
toori=[0]*(2*10**5)+[0]*n+[0]*(2*10**5)
toori[2*10**5]=1
cum=[0]*k
for a,i in enumerate (root):
s=0
for j in range (i[0],i[1]+1):
s+=toori[2*10**5+1-j]
cum[a]=s
aaa=sum(cum)%998244353
toori[2*10**5+1]+=aaa
for now in range(2,n):#nowが今の場所
hueru=0
for a,i in enumerate (root):
hueru+=(toori[2*10**5+now-i[0]] - toori[2*10**5+now-1-i[1]])
aaa+=hueru
aaa%=998244353
toori[2*10**5+now]+=aaa
toori[2*10**5+now]%=998244353
print((toori[2*10**5+n-1]%998244353)) | p02549 |
def resolve():
n, k = list(map(int, input().split()))
S = []
L, R = [], []
for _ in range(k):
l1, r1 = list(map(int, input().split()))
L.append(l1)
R.append(r1)
dp = [0 for i in range(n + 1)]
dpsum = [0 for i in range(n + 1)]
dp[1] = 1
dpsum[1] = 1
for i in range(2, n + 1):
for j in range(k):
Li = i - R[j]
Ri = i - L[j]
if Ri < 0:
continue
Li = max(1, Li)
dp[i] += dpsum[Ri] - dpsum[Li - 1] # dp[Li] ~ dp[Ri]
dpsum[i] = dpsum[i - 1] + dp[i]
print((dp[n] % 998244353))
resolve() | def resolve():
n, k = list(map(int, input().split()))
S = []
L, R = [], []
for _ in range(k):
l1, r1 = list(map(int, input().split()))
L.append(l1)
R.append(r1)
dp = [0 for i in range(n + 1)]
dpsum = [0 for i in range(n + 1)]
dp[1] = 1
dpsum[1] = 1
for i in range(2, n + 1):
for j in range(k):
Li = i - R[j]
Ri = i - L[j]
if Ri < 0:
continue
Li = max(1, Li)
dp[i] += dpsum[Ri] - dpsum[Li - 1] # dp[Li] ~ dp[Ri]
dp[i] %= 998244353
dpsum[i] = (dpsum[i - 1] + dp[i]) % 998244353
print((dp[n]))
resolve() | p02549 |
N, K = list(map(int, input().split()))
C = 998244353
S = set()
for _ in range(K):
l, r = list(map(int, input().split()))
S |= set(range(l, r+1))
# print(S)
dp = [0]*N
dp[0] = 1
for i in range(N-1):
if dp[i] == 0:
continue
for j in S:
if i+j < N:
dp[i+j] = (dp[i+j]+dp[i]) % C
# print(dp)
print((dp[-1] % C))
| N, K = list(map(int, input().split()))
C = 998244353
L = [None]*K
for j in range(K):
l, r = list(map(int, input().split()))
L[j] = [l, r+1]
dp = [0]*N
dp[0] = 1
imos = [0]*(N+1)
imsm = [0]*N
for i in range(N-1):
if i > 0:
imsm[i] = imsm[i-1]+imos[i]
dp[i] = imsm[i] % C
a = dp[i]
# print(i,dp)
for j in range(K):
l, r = L[j]
nl = min(i+l, N)
nr = min(i+r, N)
imos[nl] += a
imos[nr] -= a
# print(i, imos)
dp[N-1] = (imsm[N-2]+imos[N-1]) % C
print((dp[N-1]))
| p02549 |
N,K = list(map(int,input().split()))
S = [tuple(map(int,input().split())) for _ in range(K)]
MOD=998244353
dp=[0]*N
dp[0]=1
for i in range(N-1):
x = dp[i]
dp[0]=0
for k in range(K):
l,r = S[k]
if i+l < N:
dp[i+l]+=x
dp[i+l]%MOD
if i+r+1 < N:
dp[i+r+1]-=x
dp[i+r+1]%MOD
dp[i+1]+=dp[i]
dp[i+1]%MOD
print((dp[-1]%MOD)) | N,K = list(map(int,input().split()))
S = [tuple(map(int,input().split())) for _ in range(K)]
MOD=998244353
dp=[0]*N
dp[0]=1
for i in range(N-1):
x = dp[i]
dp[0]=0
for k in range(K):
l,r = S[k]
if i+l < N:
dp[i+l]+=x
dp[i+l]%=MOD
if i+r+1 < N:
dp[i+r+1]-=x
dp[i+r+1]%=MOD
dp[i+1]+=dp[i]
dp[i+1]%=MOD
print((dp[-1]%MOD)) | p02549 |
#!/usr/bin/env Python3
#import
#import math
#import numpy as np
#= int(input())
#= input()
modnum = 998244353
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
def mod(num):
return num % modnum
S = []
for l, r in LR:
for i in range(l, r + 1):
if not i in S:
S.append(i)
dp = [0] * N
dp[0] = 1
for i in range(1, N):
for s in S:
if not s > i:
dp[i] = mod(dp[i] + dp[i - s])
print((dp[N-1]))
| #!/usr/bin/env Python3
#import
#import math
#import numpy as np
#= int(input())
#= input()
modnum = 998244353
N, K = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(K)]
def mod(num):
return num % modnum
dp = [0] * (N + 1)
sdp = [0] * (N + 1)
dp[1] = 1
sdp[1] = 1
for i in range(2, N + 1):
for l, r in LR:
ri = max(0, i - l)
li = max(0, i - r - 1)
dp[i] += sdp[ri] - sdp[li]
dp[i] = mod(dp[i])
sdp[i] = sdp[i - 1] + dp[i]
print((dp[N]))
| p02549 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
N,K = list(map(int,input().split()))
LR = [tuple(map(int,input().split())) for i in range(K)]
LR.sort()
MOD = 998244353
arr = []
for l,r in LR:
for i in range(l,r+1):
arr.append(i)
from functools import lru_cache
@lru_cache(maxsize=10**8)
def rec(n):
if n==0: return 1
ret = 0
for a in arr:
if n-a < 0: break
ret += rec(n-a)
ret %= MOD
return ret
print((rec(N-1))) | import sys
input = sys.stdin.readline
N,K = list(map(int,input().split()))
LR = [tuple(map(int,input().split())) for i in range(K)]
MOD = 998244353
dp = [1]
cumdp = [0,1]
for i in range(1,N):
tmp = 0
for l,r in LR:
if i-l+1 <= 0: continue
tmp += cumdp[i-l+1] - cumdp[max(0,i-r)]
tmp %= MOD
dp.append(tmp)
cumdp.append((cumdp[-1] + tmp) % MOD)
print((dp[-1])) | p02549 |
def main():
N, K = list(map(int, input().split()))
MOD = 998244353
cand = set()
for _ in range(K):
L, R = list(map(int, input().split()))
A = set(range(L,R+1))
cand |= A
dp = [0] * (N + 5)
dp[0] = 1
for i in range(N):
for j in cand:
if i + j <= N:
dp[i+j] += dp[i]
dp[i+j] %= MOD
print((dp[N-1]))
if __name__ == "__main__":
main() |
def main():
N, K = list(map(int, input().split()))
MOD = 998244353
L = [0] * K
R = [0] * K
for i in range(K):
L[i], R[i] = list(map(int, input().split()))
dp = [0] * (N + 1)
dpsum = [0] * (N + 1)
dp[1] = 1
dpsum[1] = 1
for i in range(2,N+1):
for j in range(K):
l = i - R[j]
r = i - L[j]
if r <= 0:
continue
l = max(1,l)
dp[i] += dpsum[r] - dpsum[l-1]
dp[i] %= MOD
dpsum[i] = dpsum[i-1] + dp[i]
dpsum[i] %= MOD
print((dp[N]))
if __name__ == "__main__":
main()
| p02549 |
N, K = list(map(int, input().split()))
S = []
for _ in range(K):
L, R = list(map(int, input().split()))
S.extend(list(range(L,R+1)))
S.sort()
DP =[[0]*N for _ in range(N)]
DP[0][0] = 1
for i in range(N-1):
DP[i+1] = DP[i]
for j in S:
if i+j<N:
DP[i+1][i+j] += DP[i][i]
else:
break
#for i in range(N):
#print(DP[i])
print((DP[N-1][-1]%998244353)) | N, K = list(map(int, input().split()))
S = []
for _ in range(K):
L, R = list(map(int, input().split()))
S.extend(list(range(L,R+1)))
S.sort()
DP =[0]*N
DP[0] = 1
for i in range(N-1):
for j in S:
if i+j<N:
DP[i+j] += DP[i]
else:
break
print((DP[-1]%998244353)) | p02549 |
N, K = list(map(int, input().split()))
S = []
for i in range(K):
s = list(map(int, input().split()))
S.append(s)
DP = [0]*N
DP[0] = 1
#print(DP)
for i in range(1,N):
T = 0
for s in S:
l = max(0,i-s[1])
r = max(0,i-s[0]+1)
T += sum(DP[l:r])
DP[i] = T
#print(DP)
print((DP[-1]%998244353)) | N, K = list(map(int, input().split()))
L = []
R = []
for _ in range(K):
l, r = list(map(int, input().split()))
L.append(l)
R.append(r)
dp = [0]*(N+5)
dp[1] = 1
for i in range(2, N+1):
dp[i] = dp[i-1]
for j in range(K):
if i-L[j] >= 0:
dp[i] += dp[i-L[j]]
if i-R[j]-1 >= 0:
dp[i] -= dp[i-R[j]-1]
dp[i] %= 998244353
print(((dp[N]-dp[N-1])%998244353)) | p02549 |
# 配るDP、もらうDP
n, k = list(map(int, input().split()))
mod = 998244353
kukan = []
for _ in range(k):
# 区間の問題は扱いやすいように[ ) の形に直せるなら直す
l, r = list(map(int, input().split()))
l -= 1
kukan.append([l, r])
dp = [0 for i in range(n)]
dp[0] = 1
# 区間のL, Rは数字が大きいため、その差一つ一つを考えると時間がない！
# それゆえにL, Rの端を考えればいいようにするためにそこまでの累和を考える
ruiseki = [0 for i in range(n + 1)]
ruiseki[1] = 1
for i in range(1, n):
for l, r in kukan:
l = i - l
r = i - r
l, r = r, l
# print(l, r)
if r < 0:
continue
elif l >= 0:
dp[i] += (ruiseki[r] - ruiseki[l]) % mod
else:
dp[i] += (ruiseki[r]) % mod
ruiseki[i + 1] = (ruiseki[i] + dp[i])
# print(ruiseki, dp)
print((dp[-1] % mod))
| N, K = list(map(int, input().split()))
mod = 998244353
L = []
for _ in range(K):
a, b = list(map(int, input().split()))
b += 1
L.append([a, b])
ruiwa = [0] * (N + 1)
dp = [0] * (N + 1)
dp[1] = 1
ruiwa[1] = 1
for i in range(2, N + 1):
for l, r in L:
l = i - l
r = i - r
l, r = r, l
if r < 0:
continue
elif l >= 0:
# print(ruiwa, r, l)
dp[i] += (ruiwa[r] - ruiwa[l]) % mod
else:
dp[i] += ruiwa[r] % mod
ruiwa[i] = (ruiwa[i - 1] + dp[i]) % mod
print((dp[-1] % mod))
| p02549 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.