input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, K = list(map(int, input().split()))
LRs = [tuple(map(int, input().split())) for _ in range(K)]
mod = 998244353
mem = [0] * (N)
mem[N-1] = 1
for _i in range(N-1):
i = N-2 - _i
for l, r in LRs:
if i+l < N:
mem[i] += sum(mem[i+l:min(i+r+1, N)])
mem[i] %= mod
print((mem[0])) | N, K = list(map(int, input().split()))
LRs = [tuple(map(int, input().split())) for _ in range(K)]
mod = 998244353
def diff(l):
tmp = None
res = []
for elm in l:
if tmp is None:
res.append(elm)
tmp = elm
else:
res.append(elm-tmp)
tmp = elm
return res
res_diff = [0] * N
res_diff[1] = -1
res = [1]
for i in range(N-1):
for l, r in LRs:
if i+l < N:
res_diff[i+l] += res[i]
if i+r+1 < N:
res_diff[i+r+1] -= res[i]
res_next = (res[-1]+res_diff[i+1])%mod
res.append(res_next)
print((res[N-1])) | p02549 |
n,k = tuple(map(int,input().split()))
boolean = [False for _ in range(n+1)]
for _ in range(k):
l,r = tuple(map(int,input().split()))
for num in range(l,r+1):
boolean[num] = True;
dp = [0 for _ in range(n+1)]
dp[1] = 1
for i in range(2,n+1):
for lower in range(1,i):
if boolean[lower]: #start + lower
start = i - lower
dp[i]+= dp[start]
print((dp[n]%998244353)) | MOD = 998244353
N, K = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for i in range(K)]
dp = [0] * (N+1)
dp[1] = 1 #ok
for i in range(1, N):
dp[i] += dp[i-1] #as min k = 1, so carry this on to the next
dp[i] %= MOD
for l, r in LR:
ll = i + l
rr = i + r
if ll <= N:
dp[ll] += dp[i] #yes ll is accesible
dp[ll] %= MOD
if rr < N:
dp[rr+1] -= dp[i] #not accessible and will get cancelled out when we take prefix sum
dp[rr+1] %= MOD
print((dp[-1])) | p02549 |
n, k = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(k)]
MOD = 998244353
dp = [0] * n
dp[0] = 1
for i in range(n):
for l, r in LR:
for j in range(l, r + 1):
if i - j >= 0:
dp[i] += dp[i - j]
dp[i] %= MOD
print((dp[-1])) | n, k = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(k)]
MOD = 998244353
dp = [0] * n
dp[0] = 1
ruidp = [0] * (n + 1)
ruidp[1] = 1
for i in range(n):
for l, r in LR:
dp[i] += (ruidp[max(i - l + 1, 0)] - ruidp[max(i - r, 0)])
dp[i] %= MOD
ruidp[i + 1] = ruidp[i] + dp[i]
ruidp[i + 1] %= MOD
print((dp[-1]))
| p02549 |
N,K=list(map(int,input().split()))
arr={0}
for i in range(K):
a,b=list(map(int,input().split()))
arr|=set([j for j in range(a,b+1)])
arr.discard(0)
dp=[[0]*N for i in range(N)]
dp[0][0]=1
ans=0
for i in range(N):
for j in range(i,N):
if dp[i][j]!=0:
for k in arr:
if j+k<=N-1:
dp[i+1][j+k]+=dp[i][j]
ans+=dp[i][-1]
print((ans%998244353)) | N,K=list(map(int,input().split()))
arr={0}
for i in range(K):
a,b=list(map(int,input().split()))
arr|=set([j for j in range(a,b+1)])
arr.discard(0)
dp=[0]*N
dp[0]=1
ans=0
for i in range(N):
for j in arr:
if i+j<=N-1:
dp[i+j]+=dp[i]
print((dp[-1]%998244353)) | p02549 |
import sys
input = sys.stdin.readline
mod = 998244353
n, k = list(map(int, input().split()))
lr = [tuple(map(int, input().split())) for _ in range(k)]
lr.sort()
leaplist = []
for l, r in lr:
leaplist += list(range(l, r + 1))
pass
dp = [0] * n
dp[0] = 1
for i in range(1, n):
for l in leaplist:
if i < l:
break
dp[i] += dp[i - l]
dp[i] %= mod
print((dp[-1]))
| import sys
input = sys.stdin.readline
mod = 998244353
n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
lr.sort()
a = [0] * n
a[0] = 1
a[1] = -1
f = [1]
for i in range(n - 1):
for l, r in lr:
if i + l < n:
a[i + l] += f[i]
a[i + l] %= mod
else:
break
if i + r + 1 < n:
a[i + r + 1] -= f[i]
a[i + r + 1] %= mod
else:
break
f.append((f[i] + a[i + 1]) % mod)
print((f[n - 1]))
| p02549 |
import sys
input = sys.stdin.readline
mod = 998244353
n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
lr.sort()
a = [0] * n
a[0] = 1
a[1] = -1
f = [1]
for i in range(n - 1):
for l, r in lr:
if i + l < n:
a[i + l] += f[i]
a[i + l] %= mod
else:
break
if i + r + 1 < n:
a[i + r + 1] -= f[i]
a[i + r + 1] %= mod
else:
break
f.append((f[i] + a[i + 1]) % mod)
print((f[n - 1]))
| import sys
input = sys.stdin.readline
mod = 998244353
n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
lr.sort()
if lr[0][0] == 1:
f = [1, 1]
else:
f = [1, 0]
for i in range(2, n):
next_f = f[i - 1]
for l, r in lr:
if i - l >= 0:
next_f += f[i - l]
else:
break
if i - r - 1 >= 0:
next_f -= f[i - r - 1]
else:
break
f.append(next_f % mod)
print((f[n - 1]))
| p02549 |
N, K = [int(_) for _ in input().split()]
LR = [[int(_) for _ in input().split()] for _ in range(K)]
mod = 998244353
class LazySegmentTree():
def __init__(self, array, f, g, h, ti, ei):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
T x T -> T
T is dat
g : func
binary operation of the monoid
T x E -> T
T is dat, E is laz
h : func
binary operation of the monoid
E x E -> T
E is laz
ti : T
identity element of T
ei : E
identity element of E
"""
self.f = f
self.g = g
self.h = h
self.ti = ti
self.ei = ei
self.height = height = len(array).bit_length()
self.n = n = 2**height
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
self.laz = [ei] * (2 * n)
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def reflect(self, k):
dat = self.dat
ei = self.ei
laz = self.laz
g = self.g
return self.dat[k] if laz[k] is ei else g(dat[k], laz[k])
def evaluate(self, k):
laz = self.laz
ei = self.ei
reflect = self.reflect
dat = self.dat
h = self.h
if laz[k] is ei:
return
laz[(k << 1) | 0] = h(laz[(k << 1) | 0], laz[k])
laz[(k << 1) | 1] = h(laz[(k << 1) | 1], laz[k])
dat[k] = reflect(k)
laz[k] = ei
def thrust(self, k):
height = self.height
evaluate = self.evaluate
for i in range(height, 0, -1):
evaluate(k >> i)
def recalc(self, k):
dat = self.dat
reflect = self.reflect
f = self.f
while k:
k >>= 1
dat[k] = f(reflect((k << 1) | 0), reflect((k << 1) | 1))
def update(self, a, b, x): # set value at position [a, b) (0-indexed)
thrust = self.thrust
n = self.n
h = self.h
laz = self.laz
recalc = self.recalc
a += n
b += n - 1
l = a
r = b + 1
thrust(a)
thrust(b)
while l < r:
if l & 1:
laz[l] = h(laz[l], x)
l += 1
if r & 1:
r -= 1
laz[r] = h(laz[r], x)
l >>= 1
r >>= 1
recalc(a)
recalc(b)
def set_val(self, a, x):
n = self.n
thrust = self.thrust
dat = self.dat
laz = self.laz
recalc = self.recalc
ei = self.ei
a += n
thrust(a)
dat[a] = x
laz[a] = ei
recalc(a)
def query(self, a, b): # result on interval [a, b) (0-indexed)
f = self.f
ti = self.ti
n = self.n
thrust = self.thrust
reflect = self.reflect
a += n
b += n - 1
thrust(a)
thrust(b)
l = a
r = b + 1
vl = vr = ti
while l < r:
if l & 1:
vl = f(vl, reflect(l))
l += 1
if r & 1:
r -= 1
vr = f(reflect(r), vr)
l >>= 1
r >>= 1
return f(vl, vr)
#RSQ and RAQ
array = [0] + [1] + [0] * 2 * N
f = lambda a, b: a if a else b
g = lambda a, b: (a + b) % mod
h = lambda a, b: (a + b) % mod
ti = 0
ei = 0
LST = LazySegmentTree(array=array, ti=ti, ei=ei, f=f, g=g, h=h)
for x in range(1, N):
v = LST.query(x, x + 1)
for l, r in LR:
LST.update(x + l, x + r + 1, v)
ans = LST.query(N, N + 1)
print(ans)
| N, K = [int(_) for _ in input().split()]
LR = [[int(_) for _ in input().split()] for _ in range(K)]
mod = 998244353
class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_right(self, p, v): # apply operator from the right side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(dat[p], v)
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_left(self, p, v): # apply operator from the left side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(v, dat[p])
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
vl = vr = ti
l += n
r += n
while l < r:
if l & 1:
vl = f(vl, dat[l])
l += 1
if r & 1:
r -= 1
vr = f(dat[r], vr)
l >>= 1
r >>= 1
return f(vl, vr)
st = SegmentTree([0] + [1] + [0] * N, lambda x, y: x + y, 0)
for i in range(2, N + 1):
v = 0
for l, r in LR:
il = max(0, i - r)
ir = max(0, i - l + 1)
v += st.query(il, ir)
v %= mod
st.update(i, v)
ans = st.query(N, N + 1)
print(ans)
| p02549 |
N, K = list(map(int, input().split()))
mod = 998244353
D = []
dp = [0] * (N+10)
for i in range(K):
L, R = list(map(int, input().split()))
for i in range(L, R+1):
D.append(i)
D = sorted(D)
dp[0] = 1
for i in range(N):
for d in D:
if i + d > N:
continue
dp[i + d] += dp[i]
dp[i + d] %= mod
print((dp[N-1]))
| N, K = list(map(int, input().split()))
mod = 998244353
D = []
dp = [0] * (N+1)
for i in range(K):
L, R = list(map(int, input().split()))
D.append([L, R])
dp[0] = 1
a = 0
for i in range(N):
a += dp[i]
a %= mod
for d in D:
if i + d[0] > N:
continue
dp[i + d[0]] += a
dp[i + d[0]] %= mod
if i + d[1] + 1 > N:
continue
dp[i + d[1] + 1] -= a
dp[i + d[1] + 1] %= mod
print((dp[N-1]))
| 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])
a = [0 for i in range(N+1)]
a[1] = 1
b = [0 for i in range(N+1)]
b[1] = 1
for i in range(2,N+1):
for j in range(K):
if l[j][0] < i:
a[i] += b[i-l[j][0]]-b[max(0,i-l[j][1]-1)]
b[i] = b[i-1]+a[i]
mod = 998244353
print((a[N]%mod)) | 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()
a = [0 for i in range(N+1)]
a[1] = 1
b = [0 for i in range(N+1)]
b[1] = 1
for i in range(2,N+1):
for j in range(K):
if l[j][0] < i:
a[i] += b[i-l[j][0]]-b[max(0,i-l[j][1]-1)]
else:
break
b[i] = b[i-1]+a[i]
mod = 998244353
print((a[N]%mod)) | 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])
l.sort()
a = [0 for i in range(N+1)]
a[1] = 1
b = [0 for i in range(N+1)]
b[1] = 1
for i in range(2,N+1):
for j in range(K):
if l[j][0] < i:
a[i] += b[i-l[j][0]]-b[max(0,i-l[j][1]-1)]
else:
break
b[i] = b[i-1]+a[i]
mod = 998244353
print((a[N]%mod)) | N,K = list(map(int,input().split()))
l = []
mod = 998244353
for i in range(K):
L,R = list(map(int,input().split()))
l.append([L,R])
l.sort()
a = [0 for i in range(N+1)]
a[1] = 1
b = [0 for i in range(N+1)]
b[1] = 1
for i in range(2,N+1):
for j in range(K):
if l[j][0] < i:
a[i] += (b[i-l[j][0]]-b[max(0,i-l[j][1]-1)])%mod
else:
break
b[i] = (b[i-1]+a[i])%mod
mod = 998244353
print((a[N]%mod)) | p02549 |
N, K = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for _ in range(K)]
D = [1]
M = 10
memo = []
for i in range(1, N):
count = 0
for l, r in LR:
if l <= i:
ll = i - min(i, r)
rr = i - l + 1
LL = (ll + M - 1) // M
RR = rr // M
if RR > LL:
count += sum(D[ll:LL*M]) + sum(memo[LL:RR]) + sum(D[RR*M:rr])
else:
count += sum(D[ll:rr])
D.append(count % 998244353)
if len(D) % M == 0:
memo.append(sum(D[-M:]))
print((D[-1])) | N, K = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for _ in range(K)]
D = [1]
M = 1000
memo = []
for i in range(1, N):
count = 0
for l, r in LR:
if l <= i:
ll = i - min(i, r)
rr = i - l + 1
LL = (ll + M - 1) // M
RR = rr // M
if RR > LL:
count += sum(D[ll:LL*M]) + sum(memo[LL:RR]) + sum(D[RR*M:rr])
else:
count += sum(D[ll:rr])
D.append(count % 998244353)
if len(D) % M == 0:
memo.append(sum(D[-M:]))
print((D[-1])) | p02549 |
N, K = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for _ in range(K)]
D = [1]
M = 5000
memo = []
for i in range(1, N):
count = 0
for l, r in LR:
if l <= i:
ll = i - min(i, r)
rr = i - l + 1
LL = (ll + M - 1) // M
RR = rr // M
if RR > LL:
count += sum(D[ll:LL*M]) + sum(memo[LL:RR]) + sum(D[RR*M:rr])
else:
count += sum(D[ll:rr])
D.append(count % 998244353)
if len(D) % M == 0:
memo.append(sum(D[-M:]))
print((D[-1])) | N, K = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for _ in range(K)]
D = [1]
M = 100
memo = []
memo2 = []
for i in range(1, N):
count = 0
for l, r in LR:
if l <= i:
l1 = i - min(i, r)
r1 = i - l + 1
l2 = (l1 + M - 1) // M
r2 = r1 // M
l3 = (l2 + M - 1) // M
r3 = r2 // M
if r3 > l3:
count += sum(D[l1:l2*M]) + sum(memo[l2:l3*M]) + sum(memo2[l3:r3]) + sum(memo[r3*M:r2]) + sum(D[r2*M:r1])
elif r2 > l2:
count += sum(D[l1:l2*M]) + sum(memo[l2:r2]) + sum(D[r2*M:r1])
else:
count += sum(D[l1:r1])
D.append(count % 998244353)
if len(D) % M == 0:
memo.append(sum(D[-M:]))
if len(memo) % M == 0:
memo2.append(sum(memo[-M:]))
print((D[-1])) | p02549 |
n,k = list(map(int,input().split()))
jis = [list(map(int, input().split())) for _ in range(k)]
jis.sort()
dp = [0 for _ in range(n)]
dp[0] = 1
mod = 998244353
for i in range(1,n):
flag = True
for u,v in jis:
if flag is False: break
for w in range(u,v+1):
if i-w>=0:
dp[i] += dp[i - w]
dp[i] %= mod
else:
flag = False
break
print(dp[n-1]) | n,k = list(map(int,input().split()))
jis = [list(map(int, input().split())) for _ in range(k)]
jis.sort()
dp = [0 for _ in range(n)]
dp[0] = 1
pre = [0 for _ in range(n)]
pre[0] = 1
mod = 998244353
for i in range(1,n):
flag = True
for u,v in jis:
uu,vv = i - v, i - u
if vv >= 0:
dp[i] += pre[vv] - (pre[uu - 1] if uu - 1 >= 0 else 0)
dp[i] %= mod
pre[i] += dp[i] + pre[i-1]
pre[i] %= mod
print(dp[n-1]) | p02549 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 998244353
n, k = list(map(int, input().split()))
s = set()
for i in range(k):
a, b = list(map(int, input().split()))
s.update(list(range(a, b + 1)))
s = sorted(list(s))
dp = [0] + [0] * n
dp[1] = 1
for i in range(1, n + 1):
for j in s:
if i + j > n:
break
else:
dp[i + j] = (dp[i + j] + dp[i]) % MOD
print((dp[n]))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 998244353
n, k = list(map(int, input().split()))
s = list()
for i in range(k):
s.append(tuple(map(int, input().split())))
dp = [0] + [0] * n
diff = [0] + [0] * n
dp[1] = 1
for i in range(1, n):
for j, k in s:
if i + j > n:
continue
diff[i + j] += dp[i]
if i + k + 1 > n:
continue
diff[i + k + 1] -= dp[i]
dp[i] = (dp[i - 1] + diff[i]) % MOD
dp[i + 1] = (dp[i] + diff[i + 1]) % MOD
print((dp[n]))
| p02549 |
import math
class SegmentTree():
def __init__(self, size):
self.size = 2**((size-1).bit_length())
self.val = [0]*(self.size*2)
def update(self, i, x):
i += self.size
self.val[i] = x
while i > 0:
i = i >> 1
self.val[i] = self.val[2*i] + self.val[2*i+1]
def rangeSum(self, l, r):
l += self.size
r += self.size
l_sum = 0
r_sum = 0
while l < r:
if l & 1:
l_sum += self.val[l]
l += 1
l = l >> 1
if r & 1:
r -= 1
r_sum += self.val[r]
r = r >> 1
return l_sum + r_sum
p = 998244353
N, K = list(map(int, input().split()))
hop = []
for i in range(K):
L, R = list(map(int, input().split()))
for j in range(L, R + 1):
hop.append(j)
dp = SegmentTree(N)
dp.update(0,1)
for i in range(N - 1):
for j in range(len(hop)):
d_val = dp.rangeSum(i, i + 1) % p
if i + hop[j] < N:
d_val_n = dp.rangeSum(i + hop[j], i + hop[j] + 1) % p
dp.update(i + hop[j], d_val_n + d_val)
print((dp.rangeSum(N - 1, N) % p)) | class BITRAQ:
def __init__(self, n):
self.n = n + 1
self.bit = [[0]*(self.n) for _ in range(2)]
def add_sub(self, p, i, x):
while i < self.n:
self.bit[p][i] += x
i += i & -i
def add(self, l, r, x):
self.add_sub(0, l, -x * (l - 1))
self.add_sub(0, r, x * (r - 1))
self.add_sub(1, l, x)
self.add_sub(1, r, -x)
def sum_sub(self, p, i):
s = 0
while i > 0:
s += self.bit[p][i]
i -= i & -i
return s
def sum(self, i):
return self.sum_sub(0, i) + self.sum_sub(1, i) * i
def get(self, i):
return self.sum(i) - self.sum(i - 1)
p = 998244353
N, K = list(map(int, input().split()))
hop = []
for i in range(K):
hop.append(tuple(map(int, input().split())))
dp = BITRAQ(N)
dp.add(1, 2, 1)
for i in range(N - 1):
for j in range(K):
dp.add(i + hop[j][0] + 1, min(N + 1, i + hop[j][1] + 2), dp.get(i + 1) % p)
print((dp.get(N) % p)) | p02549 |
class BITRAQ:
def __init__(self, n):
self.n = n + 1
self.bit = [[0]*(self.n) for _ in range(2)]
def add_sub(self, p, i, x):
while i < self.n:
self.bit[p][i] += x
i += i & -i
def add(self, l, r, x):
self.add_sub(0, l, -x * (l - 1))
self.add_sub(0, r, x * (r - 1))
self.add_sub(1, l, x)
self.add_sub(1, r, -x)
def sum_sub(self, p, i):
s = 0
while i > 0:
s += self.bit[p][i]
i -= i & -i
return s
def sum(self, i):
return self.sum_sub(0, i) + self.sum_sub(1, i) * i
def get(self, i):
return self.sum(i) - self.sum(i - 1)
p = 998244353
N, K = list(map(int, input().split()))
hop = []
for i in range(K):
hop.append(tuple(map(int, input().split())))
dp = BITRAQ(N)
dp.add(1, 2, 1)
for i in range(N - 1):
for j in range(K):
dp.add(i + hop[j][0] + 1, min(N + 1, i + hop[j][1] + 2), dp.get(i + 1) % p)
print((dp.get(N) % p)) | class BITRAQ:
def __init__(self, n, mod):
self.n = n + 1
self.mod = mod
self.bit = [[0]*(self.n) for _ in range(2)]
def add_sub(self, p, i, x):
while i < self.n:
self.bit[p][i] += x
self.bit[p][i] %= self.mod
i += i & -i
def add(self, l, r, x):
self.add_sub(0, l, -x * (l - 1))
self.add_sub(0, r, x * (r - 1))
self.add_sub(1, l, x)
self.add_sub(1, r, -x)
def sum_sub(self, p, i):
s = 0
while i > 0:
s += self.bit[p][i]
i -= i & -i
return s
def sum(self, i):
return self.sum_sub(0, i) + self.sum_sub(1, i) * i
def get(self, i):
return self.sum(i) % self.mod - self.sum(i - 1) % self.mod
p = 998244353
N, K = list(map(int, input().split()))
hop = []
for i in range(K):
hop.append(tuple(map(int, input().split())))
dp = BITRAQ(N, p)
dp.add(1, 2, 1)
for i in range(N - 1):
for j in range(K):
dp.add(i + hop[j][0] + 1, min(N + 1, i + hop[j][1] + 2), dp.get(i + 1) % p)
print((dp.get(N) % p)) | p02549 |
mod = 998244353
def main(N, S):
dp = [0 if n != 0 else 1 for n in range(N)] # 初期値
lst_S = sorted(list(S))
for i in range(N):
if dp[i] == 0: # 計算時間削減のため， 時間さえ間に合えば不要かも．
continue
for j in lst_S:
if i + j > N - 1:
break
else:
dp[i+j] = (dp[i+j] + dp[i]) % mod
print((dp[-1]))
if __name__ == '__main__':
N, K = list(map(int, input().split()))
S = set()
for k in range(K):
L, R = list(map(int, input().split()))
{S.add(i) for i in range(L, R+1)}
main(N, S) | mod = 998244353
# 貰うDP
def main(N, S):
dp = [0 if n != 0 else 1 for n in range(N)] # dp[i]はマスiに行く通り数． (答えはdp[-1]), dp[0] = 1 (最初にいる場所だから1通り)
A = [0 if n != 0 else 1 for n in range(N)] # dp[i] = A[i] - A[i-1] (i >= 1), A[0] = dp[0] = 1 (i = 0) が成り立つような配列を考える．
for i in range(1, N): # 今いる点 (注目点)
for l, r in S: # 選択行動範囲 (l: 始点, r: 終点)
if i - l < 0: # 注目点が選択行動範囲の始点より手前の場合 → 注目点に来るために使用することはできない．
break
else: # 注目点に来るために使用することができる場合
dp[i] += A[i-l] - A[max(i-r, 0)-1] # lからrの間で，注目点に行くために使用できる点を逆算． そこに行くことができる = 選択行動範囲の値を選択することで注目点に達することができる通り数．
dp[i] %= mod
A[i] = (A[i-1] + dp[i]) % mod
print((dp[-1]))
if __name__ == '__main__':
N, K = list(map(int, input().split()))
S = {tuple(map(int, input().split())) for k in range(K)}
S = sorted(list(S), key = lambda x:x[0]) # 始点でsort (範囲の重複がないため)
main(N, S) | p02549 |
import sys
sys.setrecursionlimit(10**9)
N, K = list(map(int, input().split()))
S = set()
MOD = 998244353
for _ in range(K):
L, R = list(map(int, input().split()))
S |= set(range(L, R + 1))
# print(f'{S=}')
DP = [-1] * (N + 1)
DP[0] = 0
DP[1] = 1
def f(idx):
ans = 0
for s in S:
if idx - s < 0:
continue
if DP[idx - s] == -1:
DP[idx - s] = f(idx - s)
ans += DP[idx - s]
return ans % MOD
ans = f(N)
# print(f'{DP=}')
print(ans)
| 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))
# print(f'{LR=}')
DP = [0] * (N + 1)
DP[1] = 1
S = [0] * (N + 1)
for i in range(1, len(DP)):
for L, R in LR:
v = S[max(i - L, 0)] - S[max(i - R - 1, 0)]
DP[i] += v
DP[i] %= MOD
S[i] = (S[i - 1] + DP[i]) % MOD
# print(f'{DP=}')
# print(f'{S=}')
print((DP[-1]))
| p02549 |
from itertools import *
n, k = list(map(int, input().split()))
mod = 998244353
strides = []
for i in range(k):
l, r = list(map(int, input().split()))
for t in range(l, r + 1):
strides.append(t)
strides.sort()
d = [0] * (n + 1) # マスに対応
d[0] = 1
for i in range(1, n):
for stride in strides:
if i >= stride:
d[i] += d[i - stride]
d[i] %= mod
print((d[n-1])) | n, k = list(map(int, input().split()))
mod = 998244353
d = [0] * (n + 1)
d[1] = 1
LR =[list(map(int, input().split())) for _ in range(k)]
for i in range(2, n+1):
d[i] = d[i - 1]
for l, r in LR:
if i - l <= 0:
continue
d[i] = (d[i] + (d[i-l] - d[max(0,i-r-1)])) % mod
print(((d[-1] - d[-2])%mod)) | p02549 |
import heapq
n,k=list(map(int,input().split()))
can=[]
for i in range(k):
l,r=list(map(int,input().split()))
for j in range(l,r+1):
can.append(j)
table=[0]*n
table[0]=1
ka=[0]*(n+1)
ka[0]=1
que=[0]
heapq.heapify(que)
can.sort()
while que:
now=heapq.heappop(que)
ka[now]=0
for j in can:
if now+j>=n:
break
table[now+j]=(table[now+j]+table[now])%998244353
if ka[now+j]==0:
heapq.heappush(que,now+j)
ka[now+j]=1
print((table[-1]%998244353)) | p=998244353
n,k=list(map(int,input().split()))
kukan=[]
for i in range(k):
l,r=list(map(int,input().split()))
kukan.append((l,r))
dp=[0]*n
sdp=[0]*(n+1)
dp[0]=1
sdp[1]=1
for i in range(1,n):
for l,r in kukan:
left=max(0,i-r)
right=max(0,i-l+1)
dp[i]=(dp[i]+sdp[right]-sdp[left])%p
sdp[i+1]=(sdp[i]+dp[i])%p
print((dp[-1])) | p02549 |
def resolve():
#n=int(input())
#a,b=map(int,input().split())
#x=list(map(int,input().split()))
#a=[list(map(lambda x:int(x)%2,input().split())) for _ in range(h)]
n,k=list(map(int,input().split()))
a=set()
MOD=998244353
for i in range(k):
l,r=list(map(int,input().split()))
for j in range(l-1,r):
a.add(j)
dp=[0]*n*2
dp[0]=1
for i in range(1,n):
x=dp[i-1]
if x==0:
continue
else:
for j in a:
dp[i+j]+=x
dp[i+j]%=MOD
print((dp[n-1]))
if __name__ == '__main__':
resolve() | def resolve():
#n=int(input())
#a,b=map(int,input().split())
#x=list(map(int,input().split()))
#a=[list(map(lambda x:int(x)%2,input().split())) for _ in range(h)]
n,k=list(map(int,input().split()))
MOD=998244353
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 l,r in lr:
li=i-r
ri=i-l
if r<0:continue
li=max(1,li)
dp[i]+=dpsum[ri]-dpsum[li-1]
dpsum[i]=(dpsum[i-1]+dp[i])%MOD
print((dp[n]%MOD))
if __name__ == '__main__':
resolve() | p02549 |
MOD = 998244353
class ModInt(int):
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return ModInt(self.x + other.x) if isinstance(other, ModInt) else ModInt(self.x + other)
def __sub__(self, other):
return ModInt(self.x - other.x) if isinstance(other, ModInt) else ModInt(self.x - other)
def __mul__(self, other):
return ModInt(self.x * other.x) if isinstance(other, ModInt) else ModInt(self.x * other)
def __floordiv__(self, other):
if isinstance(other, ModInt):
return ModInt(self.x * pow(other.x, MOD - 2, MOD))
else:
if other == 0:
raise ZeroDivisionError
else:
return ModInt(self.x * pow(other, MOD - 2, MOD))
def __pow__(self, other):
return ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else ModInt(pow(self.x, other, MOD))
__radd__ = __add__
def __rsub__(self, other):
return ModInt(other.x - self.x) if isinstance(other, ModInt) else ModInt(other - self.x)
__rmul__ = __mul__
def __rfloordiv__(self, other):
return ModInt(other.x * pow(self.x, MOD - 2, MOD)) if isinstance(other, ModInt) else ModInt(other * pow(self.x, MOD - 2, MOD))
def __rpow__(self, other):
return ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else ModInt(pow(other, self.x, MOD))
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)
s = [0] * (n + 1)
dp[1] = ModInt(1)
s[1] = ModInt(1)
for i in range(2, n + 1):
for j in range(k):
l = max(1, i - R[j])
r = i - L[j]
dp[i] += s[r] - s[l - 1]
s[i] = s[i - 1] + dp[i]
print((dp[n]))
if __name__ == "__main__":
main()
| def main():
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)
s = [0] * (n + 1)
dp[1] = 1
s[1] = 1
for i in range(2, n + 1):
for j in range(k):
l = max(1, i - R[j])
r = i - L[j]
if r < 1: continue
dp[i] += s[r] - s[l - 1]
dp[i] %= MOD
s[i] = s[i - 1] + dp[i]
s[i] %= MOD
print((dp[n]))
if __name__ == "__main__":
main()
| p02549 |
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=998244353
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n,k=LI()
field=[LI() for _ in range(k)]
field.sort()
rng=[]
for x,y in field:
for z in range(x,y+1):
rng.append(z)
# print(rng)
dp=[0]*(n+1)
dp[1]=1
rng_mx=len(rng)
for i in range(1,n):
for j,dx in enumerate(rng[:rng_mx]):
if i+dx>n:
rng_mx=j+1
break
dp[i+dx]+=dp[i]
dp[i+dx]%=mod
# print(dp)
return dp[n]%mod
# main()
print((main()))
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=998244353
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n,k=LI()
field=[LI() 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 l,r in field:
li=i-r
ri=i-l
if ri<=0:
continue
li=max(1,li)
dp[i]+=dpsum[ri]-dpsum[li-1]
dp[i]%=mod
dpsum[i]=dp[i]+dpsum[i-1]
dpsum[i]%=mod
return dp[n]%mod
# main()
print((main()))
| p02549 |
inf=998244353
N,K=list(map(int,input().split()))
SS=[]
for i in range(K):
s1,s2=list(map(int,input().split()))
for j in range(s1,s2+1):
SS.append(j)
SS.sort()
table = [0 for k in range(N-1)]
for s in SS:
if s<=N-1:
table[s-1]+=1
for i in range(N-1):
if table[i]!=0:
table[i]%=inf
for s in SS:
if i+s<N-1:
table[i+s]+=table[i]
#print(table,i,s)
else:
break
print((table[-1]%inf))
| inf=998244353
N,K=list(map(int,input().split()))
SS=[list(map(int,input().split())) for i in range(K)]
SS.sort()
table = [0 for k in range(N)]
diff = [0 for k in range(N-1)]
table[0]=1
diff[0]=-1
for i in range(N-1):
if table[i]!=0:
for s in SS:
lef=s[0]
rig=s[1]
if i+lef-1<N-1:
diff[i+lef-1]+=table[i]
if i+rig<N-1:
diff[i+rig]-=table[i]
table[i+1]=table[i]+diff[i]
table[i+1]%=inf
print((table[N-1])) | p02549 |
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, K, LR):
mod = 998244353
S = []
for lr in LR:
S += [i for i in range(lr[0], lr[1] + 1)]
S.sort()
dp = [0] * (N + 1)
dp[1] = 1
for i in range(1, N + 1):
for s in S:
if i + s > N:
break
dp[i + s] = (dp[i + s] + dp[i]) % mod
print((dp[N]))
if __name__ == '__main__':
N, K = list(map(int, input().split()))
LR = [[int(i) for i in input().split()] for _ in range(K)]
solve(N,K,LR)
# # test
# from random import randint
# from func import random_str
# N, K = 2 * 10 ** 5, 1
# LR = [[1, N]]
# solve(N, K, LR)
| # 解説などを参考に作成
"""
N = 10, LR = [2, 4] を例とする.
fi:=マスiまで移動する方法の個数とおく.
便宜上0マスから始めると、
N: 0 1 2 3 4 5 6 7 8 9 10
fi: 0 1 0 1 1 2 2 4 5 8 11
となる.(1マス目には最初からいるのでf1 = 1とする.)
ここで、N=5,6の時で考えると、LR=[2,4]から
f5 = f1 + f2 + f3 (∵2～4マス前からしか遷移がないので)
f6 = f2 + f3 + f4
よってf5とf6の差はf1とf4によって求めることができる.
f6 = f5 - f1 + f4
一般化すると、
fi = fi-1 - fi-1-R + fi-L
LRが複数ある場合でも区間が重複しないので、各区間に対して - fi-1-R + fi-L 部分を計算して fi を求めることができる.
計算量はO(KN) (K:=重複しない区間LRの個数)
"""
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, K, LR):
mod = 998244353
dp = [0] * (N + 1)
dp[1] = 1
# dp[0] は基本0として扱ってよいが, dp[2]の計算時のみ,dp[0]とdp[1]の差分=0となる必要がある.
# => この時のみ、dp[0]を1として計算しないと fi = fi-1 - fi-1-R + fi-L のルールに合わなくなる.
# 他の人の解答(#16897281, #16895566)見ると階差数列？敵なのを持つことで解決できそうだったけど,
# 内容が理解できなかったのでdp[2]までは手動実装することにした.
dp[2] = 1 if 1 in [lr[0] for lr in LR] else 0
for i in range(3, N + 1):
x = 0
for l, r in LR:
x += dp[max(i - l, 0)] - dp[max(i - 1 - r, 0)]
dp[i] = (dp[i - 1] + x) % mod
print((dp[N]))
if __name__ == '__main__':
N, K = list(map(int, input().split()))
LR = [[int(i) for i in input().split()] for _ in range(K)]
solve(N, K, LR)
# # test
# from random import randint
# from func import random_str
# N, K = 2 * 10 ** 5, 1
# LR = [[1, N]]
# solve(N, K, LR)
| p02549 |
N, K = list(map(int, input().split()))
S = []
for i in range(K):
L, R = list(map(int, input().split()))
S.append((L, R))
dp = [0] * (N+1)
dpsum = [0] * (N+1)
dp[1] = 1
dpsum[1] = 1
for i in range(2, N+1):
for s in S:
l = i - s[1]
r = i - s[0]
if r < 1:continue
l = max(1, l)
dp[i] += dpsum[r] - dpsum[l-1]
dpsum[i] = dpsum[i-1] + dp[i]
print((dp[-1] % 998244353))
| mod = 998244353
N, K = list(map(int, input().split()))
S = []
for i in range(K):
L, R = list(map(int, input().split()))
S.append((L, R))
dp = [0] * (N+1)
dpsum = [0] * (N+1)
dp[1] = 1
dpsum[1] = 1
for i in range(2, N+1):
for s in S:
l = i - s[1]
r = i - s[0]
if r < 1:continue
l = max(1, l)
dp[i] += dpsum[r] - dpsum[l-1]
dp[i] %= mod
dpsum[i] = (dpsum[i-1] + dp[i]) % mod
print((dp[-1]))
| p02549 |
n, k = list(map(int, input().split()))
s = set()
for i in range(k):
l, r = list(map(int, input().split()))
for i in range(l, r+1):
s.add(i)
mod = 998244353
col = list(s)
counts = [0]*(n+1)
for i in range(1, n+1):
for c in col:
if c > i:
break
if c == i:
counts[i] += 1
counts[i] = counts[i] % mod
continue
else:
counts[i] += counts[i-c]
counts[i] = counts[i] % mod
print((counts[n-1] % mod)) | n, k = list(map(int, input().split()))
# n, k = (2*10**5, 10)
ranges = []
for i in range(k):
l, r = list(map(int, input().split()))
# f = (2 * 10 ** 5) // k
# l, r = (f * i, f*(i+1))
ranges.append((l, r))
mod = 998244353
counts = [0]*(n+1)
sum_dp = [0]*(n+2)
counts[0] = 1
sum_dp[1] = 1
for i in range(1, n+1):
for r in ranges:
left = max(0, i - r[1])
right = max(0, i - r[0] + 1)
counts[i] += (sum_dp[right] - sum_dp[left])
counts[i] = counts[i] % mod
sum_dp[i+1] = sum_dp[i] + counts[i]
print((counts[n-1] % mod)) | p02549 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 998244353
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.step = pow(2, n.bit_length() - 1)
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
def main():
N, K, *LR = list(map(int, read().split()))
interval = [(l, r) for l, r in zip(*[iter(LR)] * 2)]
bit = BIT(N + 2)
bit.add(1, 1)
bit.add(2, -1)
for i in range(N):
cur = bit.get_sum(i) % MOD
for l, r in interval:
bit.add(i + l, cur)
bit.add(i + r + 1, -cur)
print((bit.get_sum(N) % MOD))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 998244353
def main():
N, K, *LR = list(map(int, read().split()))
interval = [(l, r) for l, r in zip(*[iter(LR)] * 2)]
dp = [0] * (N + 2)
dp[1] = 1
dp[2] = -1
for i in range(1, N + 1):
dp[i] = (dp[i] + dp[i - 1]) % MOD
cur = dp[i]
for l, r in interval:
if i + l <= N:
dp[i + l] += cur
dp[min(i + r + 1, N + 1)] -= cur
print((dp[N]))
return
if __name__ == '__main__':
main()
| p02549 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 998244353
def main():
N, K, *LR = list(map(int, read().split()))
interval = [(l, r) for l, r in zip(*[iter(LR)] * 2)]
dp = [0] * (N + 2)
dp[1] = 1
dp[2] = -1
for i in range(1, N + 1):
dp[i] = (dp[i] + dp[i - 1]) % MOD
cur = dp[i]
for l, r in interval:
if i + l <= N:
dp[i + l] += cur
dp[min(i + r + 1, N + 1)] -= cur
print((dp[N]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 998244353
def main():
N, K, *LR = list(map(int, read().split()))
interval = [(l, r) for l, r in zip(*[iter(LR)] * 2)]
dp = [0] * (N + 1)
dp[1] = 1
dp[2] = -1
for i in range(1, N + 1):
dp[i] = (dp[i] + dp[i - 1]) % MOD
for l, r in interval:
if i + l <= N:
dp[i + l] += dp[i]
if i + r + 1 <= N:
dp[i + r + 1] -= dp[i]
print((dp[N]))
return
if __name__ == '__main__':
main()
| p02549 |
n,k=list(map(int,input().split()))
B=[[0]*2 for i in range(k)]
for i in range(k):
B[i]=list(map(int,input().split()))
mod=998244353
A=[0]*(n+1)
A[0]=1
a=1
for i in range(n):
for j in range(k):
A[min(n,i+B[j][0])]=A[min(n,i+B[j][0])]+a
A[min(n,i+B[j][1]+1)]=A[min(n,i+B[j][1]+1)]-a
a=a+A[i+1]
print((A[-2]%mod)) | n,k=list(map(int,input().split()))
B=[[0]*2 for i in range(k)]
for i in range(k):
B[i]=list(map(int,input().split()))
mod=998244353
A=[0]*(n+1)
A[0]=1
a=1
for i in range(n):
for j in range(k):
A[min(n,i+B[j][0])]=(A[min(n,i+B[j][0])]+a)%mod
A[min(n,i+B[j][1]+1)]=(A[min(n,i+B[j][1]+1)]-a)%mod
a=a+A[i+1]
print((A[-2]%mod)) | p02549 |
N,K=list(map(int,input().split()))
dp=[0]*(N)
dp[0]=1
mod=998244353
L=list()
for i in range(K):
a,b=list(map(int,input().split()))
L.append([a,b])
for i in range(N):
for j in range(K):
a,b=L[j]
if i>=b:
dp[i]+=sum(dp[i-b:i-a+1])
elif i>=a:
dp[i]+=sum(dp[:i-a+1])
dp[i]%=mod
print((dp[-1])) | N,K=list(map(int,input().split()))
dp=[0]*(N)
dp[0]=1
mod=998244353
L=list()
for i in range(K):
a,b=list(map(int,input().split()))
L.append([a,b])
R=[0,1]
for i in range(1,N):
for j in range(K):
a,b=L[j]
if i>=b:
dp[i]+=R[i-a+1]-R[i-b]
elif i>=a:
dp[i]+=R[i-a+1]
dp[i]%=mod
R.append(R[-1]+dp[i])
print((dp[-1])) | p02549 |
n, k = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(k)]
dp = [0]*(n+1)
dp[1] = 1
mod = 998244353
for i in range(2, n+1):
for j in range(k):
li = max(i-s[j][1], 1)
ri = i-s[j][0]
if ri < 0:
continue
dp[i] += sum(dp[li: ri+1])
dp[i] %= mod
print((dp[n]))
| n, k = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(k)]
dp = [0]*(n+1)
dp[1] = 1
mod = 998244353
dpsum = [0]*(n+1)
dpsum[1] = 1
for i in range(2, n+1):
for j in range(k):
li = max(i-s[j][1], 1)
ri = i-s[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 |
n, k = list(map(int, input().split()))
lr = [list(map(int,input().split())) for _ in range(k)]
s = []
mod = 998244353
for i in range(k):
l,r = lr[i]
for j in range(l, r+1):
s.append(j)
li = [0]*(n+1)
li[0] = 1
for i in range(n):
for j in s:
if i+j > n:
continue
li[i+j] += li[i]
li[i+j] %= mod
print((li[n-1])) | n, k = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(k)]
s = []
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 lr:
l, r = j
li = i-r
ri = i-l
if ri < 0:
continue
li = max(1,li)
dp[i] += dpsum[ri]-dpsum[li-1]
dp[i] %= mod
dpsum[i] = dpsum[i-1]+dp[i]
print((dp[n])) | p02549 |
N, K = list(map(int, input().split()))
mod = 998244353
S = []
for i in range(K):
l, r = list(map(int, input().split()))
for j in range(l, r+1):
S.append(j)
S = sorted(S)
dp = [0] * (N+1)
dp[1] = 1
for i in range(1, N):
for j in S:
if i + j > N:
break
dp[i+j] = (dp[i+j] + dp[i]) % mod
print((dp[N])) | N, K = list(map(int, input().split()))
mod = 998244353
lr = [0] * K
for i in range(K):
lr[i] = list(map(int, input().split()))
lr[i][1] += 1
dp = [0] * (N+1)
dp[1] = 1
s = 0
for i in range(1, N):
s += dp[i]
for j in range(K):
if (i + lr[j][0]) <= N:
dp[i + lr[j][0]] = (dp[i + lr[j][0]] + s) % mod
if (i + lr[j][1]) <= N:
dp[i + lr[j][1]] = (dp[i + lr[j][1]] - s) % mod
print((dp[N])) | p02549 |
p = 998244353
n, k = list(map(int, input().split()))
LRs = []
for j in range(k):
lj, rj = list(map(int, input().split()))
LRs.append((lj, rj))
A = [0] * (n + 1)
i0 = min(lj for lj, rj in LRs)
A[0] = 1
A[i0] = 1
for i in range(i0 + 1, n):
A[i] = A[i - 1]
for j in range(k):
lj, rj = LRs[j]
if i - lj >= 0:
A[i] += A[i - lj]
if i - 1 - rj >= 0:
A[i] -= A[i - 1 - rj]
A[i] %= p
print((A[n - 1]))
| p = 998244353
n, k = list(map(int, input().split()))
LRs = [tuple(map(int, input().split())) for _ in range(k)]
A = [0] * (2 * n + 1)
for lj, rj in LRs:
A[lj] += 1
A[rj + 1] -= 1
s = 0
for i in range(1, n):
s = (s + A[i]) % p
for lj, rj in LRs:
A[i + lj] += s
A[i + rj + 1] -= s
print(s)
| p02549 |
n,m,q=list(map(int,input().split()))
counts=[[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
l,r=list(map(int,input().split()))
counts[l-1][r-1]+=1
cumsum=[[0 for _ in range(n+1)] for _ in range(n)]
for i in range(n):
for j in range(n):
cumsum[i][j+1]=cumsum[i][j]+counts[i][j]
for _ in range(q):
l,r=list(map(int,input().split()))
print((sum(cumsum[i][r]-cumsum[i][l-1] for i in range(l-1,r)))) | n,m,q=list(map(int,input().split()))
counts=[[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
l,r=list(map(int,input().split()))
counts[l-1][r-1]+=1
cumsum=[[0 for _ in range(n+1)] for _ in range(n+1)]
for i in range(n):
for j in range(n):
cumsum[i+1][j+1]=cumsum[i+1][j]+counts[i][j]
for j in range(n+1):
for i in range(n):
cumsum[i+1][j]+=cumsum[i][j]
for _ in range(q):
l,r=list(map(int,input().split()))
print((cumsum[r][r]-cumsum[r][l-1]-cumsum[l-1][r]+cumsum[l-1][l-1])) | p03283 |
#!/usr/bin/env python3
import sys
def solve(N: int, M: int, Q: int, L: "List[int]", R: "List[int]", p: "List[int]", q: "List[int]"):
matrix = [[0]*(N+1) for _ in range(N+1)]
for i in range(M):
matrix[L[i]][R[i]] += 1
for j in range(Q):
answer = 0
for k in range(p[j],q[j]+1):
for l in range(p[j],q[j]+1):
answer += matrix[k][l]
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
L = [int()] * (M) # type: "List[int]"
R = [int()] * (M) # type: "List[int]"
for i in range(M):
L[i] = int(next(tokens))
R[i] = int(next(tokens))
p = [int()] * (Q) # type: "List[int]"
q = [int()] * (Q) # type: "List[int]"
for i in range(Q):
p[i] = int(next(tokens))
q[i] = int(next(tokens))
solve(N, M, Q, L, R, p, q)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, M: int, Q: int, L: "List[int]", R: "List[int]", p: "List[int]", q: "List[int]"):
matrix = [[0]*(N+1) for _ in range(N+1)]
for i in range(M):
matrix[L[i]][R[i]] += 1
ruisekiwa = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
ruisekiwa[i+1][j+1] = ruisekiwa[i][j+1] + ruisekiwa[i+1][j] - ruisekiwa[i][j] + matrix[i+1][j+1]
for j in range(Q):
qq = q[j]
pp = p[j]
answer = ruisekiwa[qq][qq] - ruisekiwa[qq][pp-1] - ruisekiwa[pp-1][qq] + ruisekiwa[pp-1][pp-1]
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
L = [int()] * (M) # type: "List[int]"
R = [int()] * (M) # type: "List[int]"
for i in range(M):
L[i] = int(next(tokens))
R[i] = int(next(tokens))
p = [int()] * (Q) # type: "List[int]"
q = [int()] * (Q) # type: "List[int]"
for i in range(Q):
p[i] = int(next(tokens))
q[i] = int(next(tokens))
solve(N, M, Q, L, R, p, q)
if __name__ == '__main__':
main()
| p03283 |
#!/usr/bin/env python3
import sys
def solve(N: int, M: int, Q: int, L: "List[int]", R: "List[int]", p: "List[int]", q: "List[int]"):
matrix = [[0]*(N+1) for _ in range(N+1)]
for i in range(M):
matrix[L[i]][R[i]] += 1
ruisekiwa = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
ruisekiwa[i+1][j+1] = ruisekiwa[i][j+1] + ruisekiwa[i+1][j] - ruisekiwa[i][j] + matrix[i+1][j+1]
for j in range(Q):
qq = q[j]
pp = p[j]
answer = ruisekiwa[qq][qq] - ruisekiwa[qq][pp-1] - ruisekiwa[pp-1][qq] + ruisekiwa[pp-1][pp-1]
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
L = [int()] * (M) # type: "List[int]"
R = [int()] * (M) # type: "List[int]"
for i in range(M):
L[i] = int(next(tokens))
R[i] = int(next(tokens))
p = [int()] * (Q) # type: "List[int]"
q = [int()] * (Q) # type: "List[int]"
for i in range(Q):
p[i] = int(next(tokens))
q[i] = int(next(tokens))
solve(N, M, Q, L, R, p, q)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, M: int, Q: int, L: "List[int]", R: "List[int]", p: "List[int]", q: "List[int]"):
matrix = [[0]*(N+1) for _ in range(N+1)]
for i in range(M):
matrix[L[i]][R[i]] += 1
for i in range(1,N+1):
for j in range(1,N+1):
matrix[i][j] += matrix[i-1][j]+matrix[i][j-1]-matrix[i-1][j-1]
for i in range(Q):
pp,qq = p[i],q[i]
print((matrix[qq][qq]-matrix[pp-1][qq]-matrix[qq][pp-1]+matrix[pp-1][pp-1]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
L = [int()] * (M) # type: "List[int]"
R = [int()] * (M) # type: "List[int]"
for i in range(M):
L[i] = int(next(tokens))
R[i] = int(next(tokens))
p = [int()] * (Q) # type: "List[int]"
q = [int()] * (Q) # type: "List[int]"
for i in range(Q):
p[i] = int(next(tokens))
q[i] = int(next(tokens))
solve(N, M, Q, L, R, p, q)
if __name__ == '__main__':
main()
| p03283 |
import sys
from collections import Counter
from collections import deque
import math
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
n,m,Q=mp()
grid=[[0]*(n+1) for i in range(n+1)]
for i in range(m):
l,r=mp()
for j in range(1,l+1):
for k in range(r,n+1):
grid[j][k]+=1
for i in range(Q):
p,q=mp()
print((grid[p][q]))
| import sys
from collections import Counter
from collections import deque
import math
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
n,m,Q=mp()
grid=[[0]*(n+1) for i in range(n+1)]
for i in range(m):
l,r=mp()
for k in range(1,l+1):
grid[k][r]+=1
for i in range(n):
for k in range(n):
grid[i][k+1]+=grid[i][k]
for i in range(Q):
p,q=mp()
print((grid[p][q])) | p03283 |
def main():
N,M,Q = list(map(int, input().split()))
X = [[0 for _ in range(N)] for _ in range(N)]
"""
for i in range(M):
l,r = map(int, input().split())
X[l-1][r-1] += 1
"""
LR = [list(map(int, input().split())) for _ in range(M)]
query = [tuple(map(int, input().split())) for _ in range(Q)]
for l,r in LR:
X[l-1][r-1] += 1
"""
C[i][j]：iから出発してjまで（ｊを含む）のどこかに行くもの
C[i][j] = X[i][i] + X[i][i+1] + ... + X[i][j-1] + X[i][j]
"""
C = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
for j in range(N):
C[i][j] = C[i][j-1] + X[i][j]
"""
print("---------------")
for a in C:
print(a)
"""
for p,q in query:
cnt = 0
for r in range(p-1,q):
cnt += C[r][q-1]
print(cnt)
if __name__ == "__main__":
main() | N,M,Q = list(map(int, input().split()))
train = [[0 for _ in range(N)] for _ in range(N)]
for _ in range(M):
l,r = list(map(int, input().split()))
train[l-1][r-1] += 1
query = [tuple(map(int, input().split())) for _ in range(Q)]
"""
l~rの間を走ってるやつ
→ {l~l + l~l+1 + l~l+2 + ... + l~r} + {l+1~l+1 + l+1~l+2 + ... + l+1~r} + ... + {r~r}
の発想
"""
accum = [[0 for _ in range(N)] for _ in range(N)]
for l in range(N):
for r in range(l,N):
if l == r:
accum[l][r] = train[l][r]
else:
# l始まりでrまでのどこかに行くやつ = l始まりでr-までのどこかに行くやつ + l始まりでrまで行くやつ
accum[l][r] = accum[l][r-1] + train[l][r]
for p,q in query:
cnt = 0
# l~rの間に完全に収まるもの = l始まりでrまでのどこかで止まるもの + l+1始まりでrまでのどこかで止まるもの + ... + r-1始まりでrまでのどこかで止まるもの + r始まりでrまでのどこかで止まるもの
for i in range(p-1,q):
cnt += accum[i][q-1]
print(cnt)
| p03283 |
n,m,q=list(map(int,input().split()))
h=[[0]*(n) for _ in range(n)]
for i in range(m):
l,r=list(map(int,input().split()))
l-=1
r-=1
h[n-1-l][r]+=1
ans=0
for i in range(n):
for j in range(n-1):
h[i][j+1] += h[i][j]
for j in range(n):
for i in range(n-1):
h[i+1][j] += h[i][j]
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((h[n-1-x][y])) | n,m,q=list(map(int,input().split()))
g=[[0]*n for _ in [0]*n]
for i in range(m):
l,r=list(map(int,input().split()))
l-=1
r-=1
g[n-l-1][r]+=1
for i in range(n):
for j in range(n-1):
g[i][j+1]+=g[i][j]
for i in range(n):
for j in range(n-1):
g[j+1][i]+=g[j][i]
for i in range(q):
p,w=list(map(int,input().split()))
p-=1
w-=1
print((g[n-1-p][w]))
| p03283 |
N, M, Q = list(map(int, input().split()))
train = []
for i in range(0, N):
train.append([])
for i in range(0, M):
L, R = list(map(int, input().split()))
train[L-1].append(R)
for i in range(0, N):
train[i-1].sort()
counter = []
for i in range(0, N):
lst = []
for j in range(0, N):
lst.append(0)
for j in range(0, len(train[i])):
lst[train[i][j]-1] = lst[train[i][j]-1] + 1
for j in range(1, len(lst)):
lst[j] = lst[j-1] + lst[j]
counter.append(lst)
for i in range(0, Q):
p, q = list(map(int, input().split()))
cnt = 0
for j in range(p-1, q):
cnt = cnt + counter[j][q-1]
print(cnt)
| N, M, Q = list(map(int, input().split()))
train = []
for i in range(0, N):
train.append([])
for i in range(0, M):
L, R = list(map(int, input().split()))
train[L-1].append(R)
for i in range(0, N):
train[i-1].sort()
counter = []
for i in range(0, N):
lst = []
for j in range(0, N):
lst.append(0)
for j in range(0, len(train[i])):
lst[train[i][j]-1] = lst[train[i][j]-1] + 1
for j in range(1, len(lst)):
lst[j] = lst[j-1] + lst[j]
counter.append(lst)
for i in range(1, N):
for j in range(0, N):
counter[N-1-i][j] = counter[N-1-i][j] + counter[N-i][j]
for i in range(0, Q):
p, q = list(map(int, input().split()))
print(counter[p-1][q-1]) | p03283 |
N, M, Q = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(M)]
Y = [list(map(int, input().split())) for _ in range(Q)]
p = [[0] * (N + 1) for _ in range(N + 1)]
for l, r in X:
p[l][r] += 1
for i in range(1, N + 1):
for j in range(1, N + 1):
p[i][j] += p[i][j - 1]
for i in range(1, N + 1):
for j in range(1, N + 1):
p[i][j] += p[i - 1][j]
for l, r in Y:
ans = p[r][r] + p[l - 1][l - 1] - p[l - 1][r] - p[r][l - 1]
print(ans)
| N, M, Q = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(M)]
Y = [list(map(int, input().split())) for _ in range(Q)]
grid = [[0] * (N + 1) for _ in range(N + 1)]
for l, r in X:
grid[l][r] += 1
for i in range(N):
for j in range(N):
grid[i + 1][j + 1] += grid[i][j + 1]
for i in range(N):
for j in range(N):
grid[i + 1][j + 1] += grid[i + 1][j]
for p, q in Y:
print((grid[q][q] + grid[p - 1][p - 1] - grid[p - 1][q] - grid[q][p - 1]))
| p03283 |
import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(100000)
def read_values():
return list(map(int, input().split()))
def read_index():
return [x - 1 for x in list(map(int, input().split()))]
def read_list():
return list(read_values())
def read_lists(N):
return [read_list() for n in range(N)]
def functional(N, mod):
F = [1] * (N + 1)
for i in range(N):
F[i + 1] = (i + 1) * F[i] % mod
return F
def main():
N, M, Q = read_values()
T = [list(read_index()) for _ in range(M)]
L0 = [0] * N
R0 = [0] * N
for i, (l, r) in enumerate(T):
L0[r] += 1 << i
R0[l] += 1 << i
for i in range(1, N):
L0[i] += L0[i - 1]
R0[-i - 1] += R0[-i]
res = [0] * Q
for i in range(Q):
p, q = read_index()
t = R0[p] & L0[q]
res[i] = str(bin(t).count("1"))
print(("\n".join(res)))
if __name__ == "__main__":
main() | import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(100000)
def read_values():
return list(map(int, input().split()))
def read_index():
return [x - 1 for x in list(map(int, input().split()))]
def read_list():
return list(read_values())
def read_lists(N):
return [read_list() for n in range(N)]
def functional(N, mod):
F = [1] * (N + 1)
for i in range(N):
F[i + 1] = (i + 1) * F[i] % mod
return F
def main():
N, M, Q = read_values()
S = [[0 for _ in range(N + 1)] for __ in range(N + 1)]
for _ in range(M):
l, r = read_values()
S[l][r] += 1
for l in range(N):
for r in range(N):
S[l + 1][r + 1] += S[l + 1][r] + S[l][r + 1] - S[l][r]
res = [0] * Q
for i in range(Q):
p, q = read_values()
res[i] = str(S[q][q] - S[p - 1][q] - S[q][p - 1] + S[p - 1][p - 1])
print(("\n".join(res)))
if __name__ == "__main__":
main() | p03283 |
from copy import deepcopy
N, M, Q = [int(elem) for elem in input().split(' ')]
lines = [[int(elem) for elem in input().split(' ')] for _ in range(M)]
queries = [[int(elem) for elem in input().split(' ')] for _ in range(Q)]
def cuml_1d(N, lines, queries):
coords = [[0] * N for _ in range(N)]
for l, r in lines:
coords[l - 1][r - 1] += 1
cuml_coords = deepcopy(coords)
for l in range(N):
for r in range(1, N):
cuml_coords[l][r] = cuml_coords[l][r - 1] + coords[l][r]
for query in queries:
p, q = query[0] - 1, query[1] - 1
num_lines = 0
for l in range(p, max(q + 1, N)):
if p == 0:
num_lines += cuml_coords[l][q]
else:
num_lines += cuml_coords[l][q] - cuml_coords[l][p - 1]
print(num_lines)
#cuml_1d(N, lines, queries)
def cuml_2d(N, lines, queries):
coords = [[0] * N for _ in range(N)]
for l, r in lines:
coords[l - 1][r - 1] += 1
cuml_l = deepcopy(coords)
for r in range(N):
for l in range(1, N):
cuml_l[l][r] = cuml_l[l - 1][r] + coords[l][r]
cuml_2d = deepcopy(cuml_l)
for l in range(N):
for r in range(1, N):
cuml_2d[l][r] = cuml_2d[l][r - 1] + cuml_l[l][r]
for query in queries:
p, q = query[0] - 1, query[1] - 1
if p != 0:
num_lines = cuml_2d[q][q] - cuml_2d[q][p-1] - cuml_2d[p-1][q] + cuml_2d[p-1][p-1]
else:
num_lines = cuml_2d[q][q]
print(num_lines)
cuml_2d(N, lines, queries)
| import sys
fin = sys.stdin.readline
N, M, Q = [int(elem) for elem in fin().split()]
trains = [[int(elem) - 1 for elem in fin().split()] for _ in range(M)]
queries = [[int(elem) - 1 for elem in fin().split()] for _ in range(Q)]
map_2D = [[0] * N for _ in range(N)]
for l, r in trains:
map_2D[l][r] += 1
cuml_1D = [[0] * N for _ in range(N)]
# vertical
for j in range(N):
cuml_sum = 0
for i in reversed(list(range(j + 1))):
cuml_sum += map_2D[i][j]
cuml_1D[i][j] = cuml_sum
cuml_2D = [[0] * N for _ in range(N)]
# horizontal
for i in range(N):
cuml_sum = 0
for j in range(N):
cuml_sum += cuml_1D[i][j]
cuml_2D[i][j] = cuml_sum
for p, q in queries:
print((cuml_2D[p][q]))
| p03283 |
# Reference: https://ikatakos.com/pot/programming_algorithm/data_structure/binary_indexed_tree
# Fenwick Tree
class BinaryIndexedTree:
# a = [0] * n
# O(n)
def __init__(self, n):
self.size = n
self.data = [0] * (n+1)
# return sum(a[0:i])
# O(log(n))
def cumulative_sum(self, i):
ans = 0
while i > 0:
ans += self.data[i]
i -= i & -i
return ans
# a[i] += x
# O(log(n))
def add(self, i, x):
i += 1
while i <= self.size:
self.data[i] += x
i += i & -i
from sys import stdin
input = stdin.buffer.readline
def main():
n, m, q = list(map(int, input().split()))
lr = [tuple(map(int, input().split())) for _ in range(m)]
pq = [(0, 0, 0)] * q
for ind in range(q):
i, j = list(map(int, input().split()))
pq[ind] = (i, j, ind)
lr.sort(key=lambda x: x[0])
l = [i for i, j in lr]
r = [j for i, j in lr]
pq.sort(key=lambda x: x[0])
BIT = BinaryIndexedTree(n+1)
for i in r:
BIT.add(i, 1)
# search r[lr_ind:]
lr_ind = 0
ans = [0] * q
for left, right, pq_ind in pq:
while lr_ind < m and l[lr_ind] < left:
BIT.add(r[lr_ind], -1)
lr_ind += 1
ans[pq_ind] = BIT.cumulative_sum(right+1)
for i in ans:
print(i)
main() | from sys import stdin
input = stdin.buffer.readline
def main():
n, m, q = list(map(int, input().split()))
# Two-dimensional Cumulative Sum
cs = [[0] * (n+1) for _ in range(n+1)]
for _ in range(m):
l, r = list(map(int, input().split()))
cs[l][r] += 1
for l in range(1, n+1):
for r in range(1, n+1):
cs[l][r] += cs[l][r-1]
for r in range(1, n+1):
cs[l][r] += cs[l-1][r]
ans = [-1] * q
for lap in range(q):
l, r = list(map(int, input().split()))
ans[lap] = cs[n][r] - cs[l-1][r]
for i in ans:
print(i)
main() | p03283 |
N,M,Q = list(map(int,input().split()))
Train = [list(map(int,input().split())) for i in range(M)]
Query = [list(map(int,input().split())) for i in range(Q)]
City = [[0]*N for i in range(N)]
Accum = [[0]*(N+1) for i in range(N+1)]
for train in Train:
City[train[0]-1][train[1]-1] += 1
for i in range(N):
for j in range(N):
Accum[i+1][j+1] = Accum[i+1][j] + City[i][j]
for j in range(N):
for i in range(N):
Accum[i+1][j+1] += Accum[i][j+1]
for query in Query:
print((
Accum[query[1]][query[1]]
- Accum[query[1]][query[0]-1]
- Accum[query[0]-1][query[1]]
+ Accum[query[0]-1][query[0]-1]
)) | import sys
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
D = [[0 for j in range(N)] for i in range(N)]
for _ in range(M):
l, r = list(map(int, input().split()))
D[l - 1][r - 1] += 1
for i in range(N):
for j in range(1, N):
D[i][j] += D[i][j - 1]
for j in range(N):
for i in range(N - 1)[::-1]:
D[i][j] += D[i + 1][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((D[p - 1][q - 1])) | p03283 |
N, M, Q = list(map(int, input().split()))
class Ruisekiwa2D:
def __init__(self, h, w):
self.H = h
self.W = w
self.G = [[0] * w for _ in range(h)]
def load(self, points):
# 問題によってイメージしやすいよう書き換えてください
# load終了時にcalcが呼ばれることに注意してください
for x, y in points:
self.G[x][y] += 1
self.calc()
def load_imos(self, points):
# pointsは[[左上h, 左上w, 右下h, 右下w], ...]であること
for i1, j1, i2, j2 in points:
self.G[i1][j1] += 1 # 左上
if j2 + 1 < self.W: # 右上
self.G[i1][j2+1] -= 1
if i2 + 1 < self.H:
self.G[i2+1][j1] -= 1 # 左下
if j2 + 1 < self.W and i2 + 1 < self.H: # 右下
self.G[i2+1][j2+1] += 1
self.calc()
def calc(self):
for y in range(self.W):
for x in range(1, self.H):
self.G[x][y] += self.G[x-1][y]
for y in range(1, self.W):
for x in range(self.H):
self.G[x][y] += self.G[x][y-1]
def get(self, i1, j1, i2, j2):
if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:
return 0
elif i1 > 0 and j1 > 0:
return self.G[i2][j2] - self.G[i1-1][j2] - self.G[i2][j1-1] + self.G[i1-1][j1-1]
elif i1 <= 0 < j1:
return self.G[i2][j2] - self.G[i2][j1-1]
elif j1 <= 0 < i1:
return self.G[i2][j2] - self.G[i1 - 1][j2]
else:
return self.G[i2][j2]
R2D = Ruisekiwa2D(N, N)
I = []
for i in range(M):
l, r = list(map(int, input().split()))
l, r = l -1, r- 1
I.append((l, r))
R2D.load(I)
for i in range(Q):
p, q = [int(x) - 1 for x in input().split()]
print((R2D.get(p, p, q, q)))
| N, M, Q = list(map(int, input().split()))
X = []
for i in range(M):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
X.append((l, r))
class Ruisekiwa2D:
def __init__(self, h, w):
self.H = h
self.W = w
self.G = [[0] * w for _ in range(h)]
def load(self, points):
# 問題によってイメージしやすいよう書き換えてください
for x, y in points:
self.G[x][y] += 1
def load_imos(self, points):
# pointsは[[左上h, 左上w, 右下h, 右下w], ...]であること
for i1, j1, i2, j2 in points:
self.G[i1][j1] += 1 # 左上
if j2 + 1 < self.W: # 右上
self.G[i1][j2+1] -= 1
if i2 + 1 < self.H:
self.G[i2+1][j1] -= 1 # 左下
if j2 + 1 < self.W and i2 + 1 < self.H: # 右下
self.G[i2+1][j2+1] += 1
def calc(self):
for y in range(self.W):
for x in range(1, self.H):
self.G[x][y] += self.G[x-1][y]
for y in range(1, self.W):
for x in range(self.H):
self.G[x][y] += self.G[x][y-1]
def get(self, i1, j1, i2, j2):
if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:
return 0
elif i1 > 0 and j1 > 0:
return self.G[i2][j2] - self.G[i1-1][j2] - self.G[i2][j1-1] + self.G[i1-1][j1-1]
elif i1 <= 0 < j1:
return self.G[i2][j2] - self.G[i2][j1-1]
elif j1 <= 0 < i1:
return self.G[i2][j2] - self.G[i1 - 1][j2]
else:
return self.G[i2][j2]
R2D = Ruisekiwa2D(N, N)
R2D.load(X)
R2D.calc()
for q in range(Q):
p, q = list(map(int, input().split()))
p, q = p - 1, q - 1
print((R2D.get(p, p, q, q)))
| p03283 |
# ABC106D - AtCoder Express 2
from itertools import accumulate as acc
def main():
# 2D cumulative sum
N, M, Q, *X = list(map(int, open(0).read().split()))
LR, PQ = X[: 2 * M], X[2 * M :]
rails = [[0] * (N + 1) for _ in range(N + 1)]
for l, r in zip(*[iter(LR)] * 2):
rails[l][r] += 1
rails = tuple(tuple(acc(a)) for a in rails)
rails = tuple(tuple(acc(a[::-1]))[::-1] for a in zip(*rails))
ans = []
for p, q in zip(*[iter(PQ)] * 2):
ans.append(rails[q][p])
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main() | # ABC106D - AtCoder Express 2
from itertools import accumulate as acc
def main():
# 2D cumulative sum
N, M, Q, *X = list(map(int, open(0).read().split()))
LR, PQ = X[: 2 * M], X[2 * M :]
rails = [[0] * (N + 1) for _ in range(N + 1)]
for l, r in zip(*[iter(LR)] * 2):
rails[l][r] += 1
rails = [list(acc(a)) for a in rails]
rails = [list(acc(a[::-1]))[::-1] for a in zip(*rails)]
ans = []
for p, q in zip(*[iter(PQ)] * 2):
ans.append(rails[q][p])
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main() | p03283 |
n, m, q = list(map(int, input().split()))
trnum = [[0 for _ in range(n+1)] for _ in range(n+1)]
cnum = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l, r = list(map(int, input().split()))
trnum[l][r] += 1
for i in range(n+1):
for j in range(n+1):
cnum[i][j] = cnum[i][j-1] + trnum[i][j]
for _ in range(q):
qp, qq = list(map(int, input().split()))
s = 0
for j in range(qp, qq+1):
s += cnum[j][qq] - cnum[j][qp-1]
print(s)
| n, m, q = list(map(int, input().split()))
trnum = [[0 for _ in range(n+1)] for _ in range(n+1)]
cnum = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l, r = list(map(int, input().split()))
trnum[l][r] += 1
for i in range(1, n+1):
for j in range(1, n+1):
trnum[i][j] += trnum[i][j-1]
for i in range(1, n+1):
for j in range(1, n+1):
trnum[i][j] += trnum[i-1][j]
for _ in range(q):
l, r = list(map(int, input().split()))
print((trnum[r][r] + trnum[l-1][l-1] - trnum[l-1][r] - trnum[r][l-1]))
| p03283 |
N, M, Q = list(map(int, input().split()))
LR = [[0 for i in range(501)] for j in range(501)]
for i in range(M):
L, R = list(map(int, input().split()))
LR[L][R] += 1
LR2 = [[0 for i in range(501)] for j in range(501)]
for i in range(1, 501):
for j in range(1, 501):
LR2[i][j] = LR2[i][j - 1] + LR[i][j]
for i in range(Q):
ans = 0
p, q = list(map(int, input().split()))
for i in range(p, q + 1):
ans = ans + LR2[i][q] - LR2[i][p - 1]
print(ans)
| N, M, Q = list(map(int, input().split()))
LR = [[0 for i in range(N)] for j in range(N)]
for i in range(M):
L, R = list(map(int, input().split()))
LR[L - 1][R - 1] += 1
for i in range(1, N):
LR[0][i] += LR[0][i - 1]
LR[i][0] += LR[i - 1][0]
for i in range(1, N):
for j in range(1, N):
LR[i][j] = LR[i - 1][j] + LR[i][j - 1] + LR[i][j] - LR[i - 1][j - 1]
for i in range(Q):
p, q = list(map(int, input().split()))
p -= 2
q -= 1
if p != -1:
ans = LR[q][q] - LR[q][p] - LR[p][q] + LR[p][p]
elif p == -1:
ans = LR[q][q]
print(ans)
| p03283 |
n,m,Q = list(map(int, input().split()))
train = []
for i in range(n):
a = []
for j in range(n):
a.append(0)
train.append(a)
for i in range(m):
l,r = list(map(int, input().split()))
train[l-1][r-1] += 1
for i in range(n):
lst = [0,train[i][0]]
for j in range(1,n):
lst.append(lst[j]+train[i][j])
train[i] = lst
pq = []
for i in range(Q):
p,q = list(map(int, input().split()))
ans = 0
for i in range(p-1,q):
ans += train[i][q]
print(ans)
| n,m,Q = list(map(int, input().split()))
train = []
for i in range(n):
a = []
for j in range(n):
a.append(0)
train.append(a)
for i in range(m):
l,r = list(map(int, input().split()))
train[l-1][r-1] += 1
cumsum = []
list1 = []
for i in range(n+1):
list1.append(0)
cumsum.append(list1)
for i in range(n):
lst = [0,cumsum[i][1]+train[i][0]]
for j in range(1,n):
lst.append(lst[j]+train[i][j]+(cumsum[i][j+1]-cumsum[i][j]))
cumsum.append(lst)
for i in range(Q):
p,q = list(map(int, input().split()))
print((cumsum[q][q]-cumsum[p-1][q]-cumsum[q][p-1]+cumsum[p-1][p-1])) | p03283 |
import collections
import bisect
import copy
def main():
N, M, Q = list(map(int, input().split()))
train = []
for _ in range(M):
l, r = list(map(int, input().split()))
train.append([l, r])
train.sort()
# print(train)
end = []
ends = []
j = M-1
for i in range(N, 0, -1):
while j >= 0 and train[j][0] >= i:
l, r = train[j]
bisect.insort(end, r)
j -= 1
ends.append(copy.copy(end))
ends.append([])
ends = ends[::-1]
# print(N)
# print(ends)
for _ in range(Q):
p, q = list(map(int, input().split()))
j = bisect.bisect_right(ends[p], q)
print(j)
if __name__ == '__main__':
main() | def main():
N, M, Q = list(map(int, input().split()))
train = [[0 for _ in range(N)] for _ in range(N)]
for _ in range(M):
l, r = list(map(int, input().split()))
train[l-1][r-1] += 1
accum = [[0 for _ in range(N+1)]]
for i in range(N):
temp = [0]
v = 0
for j in range(N):
v += train[i][j]
temp.append(accum[-1][j+1]+v)
accum.append(temp)
# print(temp)
for _ in range(Q):
p, q = list(map(int, input().split()))
v = accum[q][q] - accum[p-1][q] - accum[q][p-1] + accum[p-1][p-1]
print(v)
if __name__ == '__main__':
main() | p03283 |
N,M,Q = list(map(int,input().split()))
Section = [[0]*N for _ in range(N)]
for _ in range(M):
L,R = list(map(int,input().split()))
Section[L-1][R-1] += 1
Sum = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
Sum[i+1][j+1] = Sum[i][j+1]+Sum[i+1][j]-Sum[i][j]+Section[i][j]
Ans = [[0]*N for _ in range(N)]
for i in range(N):
for j in range(i,N):
Ans[i][j] = Sum[j+1][j+1]-Sum[i][j+1]
for _ in range(Q):
p,q = list(map(int,input().split()))
print((Ans[p-1][q-1])) | import sys
s = sys.stdin.readlines()
N,M,Q = list(map(int,s[0].split()))
Section = [[0]*N for _ in range(N)]
for L,R in (list(map(int, e.split())) for e in s[1:M+1]):
Section[L-1][R-1] += 1
Sum = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
Sum[i+1][j+1] = Sum[i][j+1]+Sum[i+1][j]-Sum[i][j]+Section[i][j]
Ans = [[0]*N for _ in range(N)]
for i in range(N):
for j in range(i,N):
Ans[i][j] = Sum[j+1][j+1]-Sum[i][j+1]
for p,q in (list(map(int, e.split())) for e in s[M+1:]):
print((Ans[p-1][q-1])) | p03283 |
import sys
s = sys.stdin.readlines()
N,M,Q = list(map(int,s[0].split()))
Section = [[0]*N for _ in range(N)]
for L,R in (list(map(int, e.split())) for e in s[1:M+1]):
Section[L-1][R-1] += 1
Sum = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
Sum[i+1][j+1] = Sum[i][j+1]+Sum[i+1][j]-Sum[i][j]+Section[i][j]
Ans = [[0]*N for _ in range(N)]
for i in range(N):
for j in range(i,N):
Ans[i][j] = Sum[j+1][j+1]-Sum[i][j+1]
for p,q in (list(map(int, e.split())) for e in s[M+1:]):
print((Ans[p-1][q-1])) | import sys
s = sys.stdin.readlines()
N,M,Q = list(map(int,s[0].split()))
Section = [[0]*N for _ in range(N)]
for L,R in (list(map(int, e.split())) for e in s[1:M+1]):
Section[L-1][R-1] += 1
Sum = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
Sum[i+1][j+1] = Sum[i][j+1]+Sum[i+1][j]-Sum[i][j]+Section[i][j]
for p,q in (list(map(int, e.split())) for e in s[M+1:]):
print((Sum[q][q]-Sum[p-1][q])) | p03283 |
n,m,q = list(map(int, input().split()))
mmap = [ [ 0 for j in range(n+1) ] for i in range(n+1) ]
for i in range(m):
s,e = list(map(int, input().split()))
mmap[s][e] += 1
for i in range(q):
s,e = list(map(int, input().split()))
cnt = 0
for j in range(s,e+1):
for k in range(s,e+1):
cnt += mmap[j][k]
print(cnt) | n,m,q = list(map(int, input().split()))
mmap = [ [ 0 for j in range(n+1) ] for i in range(n+1) ]
for i in range(m):
s,e = list(map(int, input().split()))
mmap[s][e] += 1
for i in range(n+1):
for j in range(1,n+1):
mmap[i][j] = mmap[i][j] + mmap[i][j-1]
for j in range(n+1):
for i in range(n-1,0,-1):
mmap[i][j] = mmap[i][j] + mmap[i+1][j]
for i in range(q):
s,e = list(map(int, input().split()))
print((mmap[s][e])) | p03283 |
# input
N, M, Q = list(map(int, input().split()))
Trains = [list(map(int, input().split())) for _ in range(M)]
Trains = sorted(Trains)
Questions = {}
for i in range(Q):
Questions[i] = list(map(int, input().split()))
Questions = sorted(list(Questions.items()), key = lambda x: x[1])
Ans = [0 for _ in range(Q)]
left = 0
for i in range(Q):
num = Questions[i][0]
p = Questions[i][1][0]
q = Questions[i][1][1]
for j in range(left, M):
if p <= Trains[j][0]:
left = j
for k in range(j, M):
if q >= Trains[k][1]:
Ans[num] += 1
break
for i in range(Q):
print((Ans[i]))
| # input
N, M, Q = list(map(int, input().split()))
train_query = {} # 対象区間とクエリを一緒にソート
for i in range(M + Q):
train_query[i] = list(map(int, input().split()))
train_query = sorted(list(train_query.items()), key=lambda x: x[1][1])
# 辞書をソートするとリストが返ってくることに注意
StartPoints = [0 for _ in range(N)] # 対象区間の開始位置
ans = [0 for _ in range(Q)] # 各クエリに対する答え
for j in range(M + Q):
if train_query[j][0] < M: # 対象区間
StartPoints[train_query[j][1][0] - 1] += 1
else: # クエリ
ans[train_query[j][0] - M] = sum(StartPoints[(train_query[j][1][0] - 1):(train_query[j][1][1])])
for i in range(Q):
print((ans[i]))
| p03283 |
n, m, q = list(map(int,input().split()))
ways = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(m):
l,r = list(map(int,input().split()))
ways[l][r] += 1
sgways = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(i,n+1):
for k in range(i,j+1):
sgways[i][j] += ways[k][j]
ans = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(i,n+1):
for k in range(i,j+1):
ans[i][j] += sgways[i][k]
for i in range(q):
pi,qi = list(map(int,input().split()))
print((ans[pi][qi]))
| n, m, q = list(map(int,input().split()))
ways = [[0 for i in range(n+2)] for j in range(n+2)]
for i in range(m):
l,r = list(map(int,input().split()))
ways[l][r] += 1
sgways = [[0 for i in range(n+2)] for j in range(n+2)]
for j in range(1,n+1):
for i in range(j):
sgways[j-i][j] = sgways[j-i+1][j] +ways[j-i][j]
ans = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(i,n+1):
ans[i][j] = ans[i][j-1]+sgways[i][j]
for i in range(q):
pi,qi = list(map(int,input().split()))
print((ans[pi][qi]))
| p03283 |
N, M, Q = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(M)]
pq = [list(map(int, input().split())) for _ in range(Q)]
XY = [[0 for _ in range(N)] for _ in range(N)]
for l, r in LR:
XY[l - 1][r - 1] += 1
for i in range(N):
for j in range(N - 1):
XY[i][j + 1] += XY[i][j]
for p, q in pq:
count = 0
for i in range(p - 1, q):
if p - 2 >= 0:
count += XY[i][q - 1] - XY[i][p - 2]
else:
count += XY[i][q - 1] - 0
print(count)
| N, M, Q = list(map(int, input().split()))
LR = [list(map(int, input().split())) for _ in range(M)]
pq = [list(map(int, input().split())) for _ in range(Q)]
XY = [[0 for _ in range(N)] for _ in range(N)]
for l, r in LR:
XY[l - 1][r - 1] += 1
for i in range(N):
for j in range(N):
if i == 0 and j == 0:
pass
elif i == 0:
XY[i][j] += XY[i][j - 1]
elif j == 0:
XY[i][j] += XY[i - 1][j]
pre_im1_j = XY[i - 1][j]
else:
if XY[i - 1][j] == pre_im1_j:
XY[i][j] += XY[i][j - 1]
else:
XY[i][j] += XY[i][j - 1] + XY[i - 1][j] - pre_im1_j
pre_im1_j = XY[i - 1][j]
for p, q in pq:
if p != 1:
print((XY[q - 1][q - 1] + XY[p - 2][p - 2] - XY[p - 2][q - 1] - XY[q - 1][p - 2]))
else:
print((XY[q - 1][q - 1]))
| p03283 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
#from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
N, M, Q = na()
dp = [[0] * (N + 3) for _ in range(N + 3)]
for i in range(M):
l, r = na()
for x in range(1, l+1):
for y in range(r, N+1):
dp[x][y] += 1
for i in range(Q):
p, q = na()
print((dp[p][q]))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
stdin = sys.stdin
ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
N, M, Q = na()
dp = [[0] * (N + 3) for _ in range(N + 3)]
for i in range(M):
l, r = na()
dp[1][r] += 1
dp[l+1][r] -= 1
dp[l][N+1] -= 1
for i in range(N+1):
for j in range(N+1):
dp[i][j+1] += dp[i][j]
for j in range(N+1):
for i in range(N+1):
dp[i+1][j] += dp[i][j]
for i in range(Q):
p, q = na()
print((dp[p][q]))
| p03283 |
n, m, q = list(map(int, input().split()))
x = [[0]*n for _ in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
l, r = l-1, r-1
x[l][r] += 1
s = [[0]*(n+1) for _ in range(n+1)]
for i in range(n):
for j in range(n):
s[i+1][j+1] = s[i+1][j] + s[i][j+1] - s[i][j] + x[i][j]
for _ in range(q):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
print((s[b+1][b+1] - s[b+1][a] - s[a][b+1] + s[a][a])) | n, m, q = list(map(int, input().split()))
A = [[0]*n for i in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
l, r = l-1, r-1
A[l][r] += 1
#print(A)
s = [[0]*(n+1) for _ in range(n+1)]
for i in range(n):
for j in range(n):
s[i+1][j+1] = s[i+1][j] + s[i][j+1] - s[i][j] + A[i][j]
#print(s)
for i in range(q):
p, q = list(map(int, input().split()))
p, q = p-1, q-1
ans = s[q+1][q+1] - s[p][q+1] - s[q+1][p] + s[p][p]
print(ans)
| p03283 |
from itertools import accumulate
N, M, Q = list(map(int, input().split()))
D = [[0] * (N + 1) for i in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
D[L][R] += 1
for i in range(N - 1, 0, -1):
for j in range(1, N + 1):
D[i][j] += D[i + 1][j]
for i in range(1, N + 1):
D[i] = list(accumulate(D[i]))
for _ in range(Q):
p, q = list(map(int, input().split()))
print((D[p][q])) | from sys import stdin
from itertools import accumulate
input = stdin.readline
N, M, Q = list(map(int, input().split()))
D = [[0] * (N + 1) for i in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
D[L][R] += 1
for i in range(N - 1, 0, -1):
for j in range(i, N + 1):
D[i][j] += D[i + 1][j]
for i in range(1, N + 1):
D[i] = list(accumulate(D[i]))
for _ in range(Q):
p, q = list(map(int, input().split()))
print((D[p][q])) | p03283 |
import sys
input = sys.stdin.readline
N, M, Q = [int(x) for x in input().split()]
L = [0] * M
R = [0] * M
p = [0] * Q
q = [0] * Q
for i in range(M):
L[i], R[i] = [int(x) for x in input().split()]
for j in range(Q):
p[j], q[j] = [int(x) for x in input().split()]
train = [[0 for i in range(N + 1)] for _ in range(N + 1)]
seg = [[0 for i in range(N + 1)] for _ in range(N + 2)]
for i in range(M): # すべての列車について
train[L[i]][R[i]] += 1
for col in range(1, N + 1):
for row in range(col, 0, -1):
seg[row][col] = train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1]
for j in range(Q):
print((seg[p[j]][q[j]]))
| import sys
input = sys.stdin.readline
N, M, Q = [int(x) for x in input().split()]
L = [0] * M
R = [0] * M
p = [0] * Q
q = [0] * Q
for i in range(M):
L[i], R[i] = [int(x) for x in input().split()]
for j in range(Q):
p[j], q[j] = [int(x) for x in input().split()]
train = [[0 for i in range(N + 1)] for _ in range(N + 2)]
for i in range(M): # すべての列車について
train[L[i]][R[i]] += 1
for col in range(1, N + 1):
for row in range(col, 0, -1):
train[row][col] += train[row][col - 1] + train[row + 1][col] - train[row + 1][col - 1]
for j in range(Q):
print((train[p[j]][q[j]]))
| p03283 |
N, M, Q = list(map( int, input().split()))
NN = [ [ 0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L, R = list(map( int, input().split()))
NN[L][R] += 1
Sum = [ [ 0 ] for _ in range(N+1)]
for i in range(1,N+1):
for j in range(1,N+1):
Sum[i].append(Sum[i][-1]+NN[i][j])
for _ in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for i in range(p,q+1):
ans += Sum[i][q] - Sum[i][p-1]
print(ans) | N, M, Q = list(map( int, input().split()))
NN = [ [0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L, R = list(map( int, input().split()))
NN[L][R] += 1
for i in range(1,N+1):
for j in range(1,N+1):
NN[i][j] += NN[i][j-1]+NN[i-1][j]-NN[i-1][j-1]
for _ in range(Q):
p, q = list(map( int, input().split()))
print((NN[q][q]-NN[q][p-1]-NN[p-1][q]+NN[p-1][p-1])) | p03283 |
N,M,Q = list(map(int,input().split()))
station = [[0]*N for i in range(N)]
for i in range(M):
L,R = list(map(int,input().split()))
station[L-1][R-1] += 1
DP = [[0]*(N) for i in range(N)]
for i in range(N):
for j in range(N):
for a in range(i,j+1):
for b in range(i,j+1):
DP[i][j] += station[a][b]
for i in range(Q):
p,q = list(map(int,input().split()))
print((DP[p-1][q-1])) | N,M,Q = list(map(int,input().split()))
station = [[0]*(N+1) for i in range(N+1)]
for i in range(M):
l,r = list(map(int,input().split()))
station[l][r] += 1
DP = [[0]*(N+1) for i in range(N+1)]
for i in range(N+1):
for j in range(N):
DP[i][j+1] = DP[i][j] + station[i][j+1]
for i in range(Q):
p,q = list(map(int,input().split()))
ans = 0
for i in range(p,q+1):
ans += DP[i][q] - DP[i][p-1]
print(ans) | p03283 |
n, m, q = list(map(int, input().split()))
tr = []
for i in range(m):
l, r = list(map(int, input().split()))
tr.append((l, r))
qu = []
for i in range(q):
p, q = list(map(int, input().split()))
qu.append((p, q))
print((len(list([s for s in tr if p <= s[0] and s[1] <= q])))) | n, m, q = list(map(int, input().split()))
T = [[0] * n for i in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
T[l - 1][r - 1] += 1
for i in range(n):
for j in range(1, n):
T[i][j] += T[i][j - 1]
for j in range(n):
for i in range(n - 2, -1, -1):
T[i][j] += T[i + 1][j]
for i in range(q):
p, q = list(map(int, input().split()))
print((T[p - 1][q - 1]))
| p03283 |
from copy import deepcopy
n, m, q = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(m)]
pq = [list(map(int, input().split())) for _ in range(q)]
cnt = [[0] * (n + 1) for _ in range(n + 1)]
for l, r in lr:
cnt[l][r] += 1
acc = deepcopy(cnt)
for i in range(n):
for j in range(n):
tmp = acc[i][j + 1] + acc[i + 1][j] - acc[i][j]
acc[i + 1][j + 1] += tmp
for p, q in pq:
p -= 1
ans = acc[q][q] - acc[p][q] - acc[q][p] + acc[p][p]
print(ans)
| n, m, q = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(m)]
pq = [list(map(int, input().split())) for _ in range(q)]
acc = [[0] * (n + 1) for _ in range(n + 1)]
for l, r in lr:
acc[l][r] += 1
for i in range(n):
for j in range(n):
tmp = acc[i][j + 1] + acc[i + 1][j] - acc[i][j]
acc[i + 1][j + 1] += tmp
for p, q in pq:
p -= 1
ans = acc[q][q] - acc[p][q] - acc[q][p] + acc[p][p]
print(ans)
| p03283 |
N, M, Q = list(map(int, input().split()))
X = [[0 for j in range(510)] for i in range(510)]
C = [[0 for j in range(510)] for i in range(510)]
LR = []
for i in range(M):
L, R = list(map(int, input().split()))
X[L][R] += 1
for i in range(1, N+1):
for j in range(1, N+1):
C[i][j] = C[i][j-1]+X[i][j]
for i in range(Q):
p, q = list(map(int, input().split()))
sum = 0
for j in range(p, q+1):
sum += C[j][q]-C[j][p-1]
print(sum)
| N, M, Q = list(map(int, input().split()))
# 入力
A = [[0 for j in range(N+1)] for i in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
A[L][R] += 1
# 二次元累積和
Cum = [[0 for j in range(N+1)] for i in range(N+1)]
for i in range(N):
for j in range(N):
Cum[i+1][j+1] = Cum[i][j+1] + Cum[i+1][j] - Cum[i][j] + A[i+1][j+1]
# クエリ処理
for _ in range(Q):
p, q = list(map(int, input().split()))
print((Cum[q][q]-Cum[p-1][q]-Cum[q][p-1]+Cum[p-1][p-1]))
| p03283 |
n,m,q=list(map(int,input().split()))
g=[[0 for i in range(n)] for j in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
g[a][b]+=1
r=[[0 for i in range(n+1)] for j in range(n)]
for i in range(n):
for j in range(1,n+1):
r[i][j]=r[i][j-1]+g[i][j-1]
for i in range(q):
a,b=list(map(int,input().split()))
a-=1
b-=1
ans=0
for i in range(a,b+1):
ans+=r[i][b+1]-r[i][a]
print(ans)
| n,m,q=list(map(int,input().split()))
g=[[0 for i in range(n+1)] for j in range(n+1)]
for i in range(m):
a,b=list(map(int,input().split()))
#a-=1
#b-=1
g[a][b]+=1
for i in range(n):
for j in range(n+1):
g[i+1][j]+=g[i][j]
for i in range(n+1):
for j in range(n):
g[i][j+1]+=g[i][j]
for i in range(q):
a,b=list(map(int,input().split()))
a-=1
print((g[b][b]+g[a][a]-g[a][b]-g[b][a]))
#print(g) | p03283 |
n, m, Q = list(map(int, input().split()))
LR = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
l, r = list(map(int, input().split()))
LR[l-1][r-1] += 1
# 各Lについて累積和を取る
LR_rui = [[0] for _ in range(n)]
for i in range(n):
for j in range(n):
LR_rui[i].append(LR[i][j]+LR_rui[i][-1])
for _ in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for i in range(p, q+1):
ans += LR_rui[i-1][q] - LR_rui[i-1][p-1]
print(ans)
| n, m, Q = list(map(int, input().split()))
LR = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
l, r = list(map(int, input().split()))
LR[l-1][r-1] += 1
# 二次元累積和の作成
LR_rui = [[0 for _ in range(n+1)] for _ in range(n+1)]
# 各Lについての累積
for i in range(n):
for j in range(n):
LR_rui[i+1][j+1] = LR_rui[i+1][j]+LR[i][j]
# 各Rについての累積:
for i in range(n):
for j in range(n):
LR_rui[i+1][j+1] = LR_rui[i+1][j+1] + LR_rui[i][j+1]
for _ in range(Q):
p, q = list(map(int, input().split()))
ans = LR_rui[q][q] - LR_rui[p-1][q] - LR_rui[q][p-1] + LR_rui[p-1][p-1]
print(ans) | p03283 |
n,m,q = list(map(int,input().split()))
lr = [[0 for i in range(n+1)] for j in range(n+1)]
#lr = [[int(i) for i in input().split()]for j in range(m)]
st = [0] * (n+1)
ed = [0] * (n+1)
for i in range(m):
l,r = list(map(int,input().split()))
lr[l][r] += 1
pq = [[int(i) for i in input().split()]for j in range(q)]
dp = [[0 for i in range(n+1)] for j in range(n+1)]
#print(lr)
for i in range(1,n+1):
#print(i)
for j in range(i,n+1):
#print(i,j)
dp[i][j] = dp[i][j-1]+lr[i][j]
for i in range(q):
st = pq[i][0]
ed = pq[i][1]
tmp = 0
for j in range(ed-st+1):
tmp += dp[st+j][ed]
print(tmp)
#print(dp) | n,m,q = list(map(int,input().split()))
lr = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(m):
l,r = list(map(int,input().split()))
lr[l][r] += 1
pq = [[int(i) for i in input().split()]for j in range(q)]
dp = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(i,n+1):
dp[i][j] = dp[i][j-1]+lr[i][j]
ans_dp = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(i,n+1):
tmp = 0
for k in range(j-i+1):
tmp += dp[i+k][j]
ans_dp[i][j] = tmp
for i in range(q):
print((ans_dp[pq[i][0]][pq[i][1]]))
| p03283 |
N,M,Q=list(map(int,input().split()))
Town=[[int(i) for i in input().split()] for i in range(M)]
Town.sort(key=lambda x:x[0])
def BS_left(x,L,s):
L_copy=L[:]
left=0
if L[s-1]<x:
return s-1
else:
while s>2:
if L_copy[s//2]<x:
L_copy=L_copy[s//2:s]
left+=s//2
s=s-s//2
else:
L_copy=L_copy[0:s//2+1]
s=s//2+1
if L[left]>=x:
return left-1
else:
return left
def BS_right(x,L,s):
L_copy=L[:]
right=s-1
if L[0]>x:
return 0
else:
while s>2:
if L_copy[s//2]<=x:
L_copy=L_copy[s//2:s]
s=s-s//2
else:
L_copy=L_copy[0:s//2+1]
right+=-s//2+1
s=s//2+1
if L[right]<=x:
return right+1
else:
return right
ans=[0]*Q
for i in range(Q):
p,q=list(map(int,input().split()))
for i in zip(*Town):
TownL=i
break
a=BS_left(p,TownL,M)+1
newTown=Town[a:]
if M-a==0:
print((0))
else:
newTown.sort(key=lambda x:x[1])
e=0
for i in zip(*newTown):
if e==0:
e+=1
else:
TownR=i
break
b=BS_right(q,TownR,M-a)
if b==1 and TownR[0]>q:
print((0))
else:
print(b)
| N,M,Q=list(map(int,input().split()))
Train=[[int(i) for i in input().split()] for i in range(M)]
Map=[[0]*(N+1) for i in range(N+1)]
for i in Train:
x,y=i[0],i[1]
Map[y][x]+=1
for a in range(1,N+1):
for b in range(1,N+1):
if b<=N-1:
Map[a][b+1]=Map[a][b]+Map[a][b+1]
if a>=2:
Map[a][b]=Map[a-1][b]+Map[a][b]
for i in range(Q):
p,q=list(map(int,input().split()))
print((Map[q][q]-Map[q][p-1]-Map[p-1][q]+Map[p-1][p-1]))
| p03283 |
N, M, Q = list(map(int, input().split()))
A = [[0] * N for _ in range(N)]
for _ in range(M):
l, m = list(map(int, input().split()))
A[l - 1][m - 1] += 1
questions = []
for _ in range(Q):
p, q = list(map(int, input().split()))
questions.append((p - 1, q - 1))
D = []
for l in range(N):
s = 0
d = []
for r in range(N):
s += A[l][r]
d.append(s)
D.append(d)
for question in questions:
print((sum([D[i][question[1]] for i in range(question[0], N)])))
| N, M, Q = list(map(int, input().split()))
A = [[0] * N for _ in range(N)]
for _ in range(M):
l, m = list(map(int, input().split()))
A[l - 1][m - 1] += 1
questions = []
for _ in range(Q):
p, q = list(map(int, input().split()))
questions.append((p - 1, q - 1))
D = []
for l in range(N):
s = 0
d = []
for r in range(N):
s += A[l][r]
d.append(s)
D.append(d)
T = []
for r in range(N):
s = 0
t = [0]
for l in range(N):
s += D[l][r]
t.append(s)
T.append(t)
for question in questions:
print((T[question[1]][N] - T[question[1]][question[0]]))
| p03283 |
N, M, Q = list(map(int, input().split()))
A = [[0] * N for _ in range(N)]
for _ in range(M):
l, m = list(map(int, input().split()))
A[l - 1][m - 1] += 1
questions = []
for _ in range(Q):
p, q = list(map(int, input().split()))
questions.append((p - 1, q - 1))
D = []
for l in range(N):
s = 0
d = []
for r in range(N):
s += A[l][r]
d.append(s)
D.append(d)
for question in questions:
print((sum([D[i][question[1]]
for i in range(question[0], question[1] + 1)])))
| N, M, Q = list(map(int, input().split()))
A = [[0] * N for _ in range(N)]
for _ in range(M):
l, m = list(map(int, input().split()))
A[l - 1][m - 1] += 1
questions = []
for _ in range(Q):
p, q = list(map(int, input().split()))
questions.append((p - 1, q - 1))
D = []
for l in range(N):
s = 0
d = []
for r in range(N):
s += A[l][r]
d.append(s)
D.append(d)
T = []
for r in range(N):
s = 0
t = []
for l in range(N):
s += D[N - l - 1][r]
t.append(s)
T.append(t)
for question in questions:
print((T[question[1]][N - question[0] - 1]))
| p03283 |
n, m, Q = list(map(int, input().split()))
imos = [[0 for i in range(n)] for j in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
l -= 1
r -= 1
imos[l][r] += 1
for i in range(n):
for j in range(n-1):
imos[i][j+1] += imos[i][j]
for j in range(n):
for i in range(n-1):
imos[i+1][j] += imos[i][j]
for i in range(Q):
p, q = list(map(int, input().split()))
p -= 1
q -= 1
if p == 0:
print((imos[q][q]))
else:
print((imos[q][q] - imos[p-1][q]))
| n, m, q = list(map(int, input().split()))
imos = [[0 for i in range(n)] for j in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
imos[l-1][r-1] += 1
for i in range(n):
for j in range(n-1):
imos[i][j+1] += imos[i][j]
for j in range(n):
for i in range(n-1):
imos[i+1][j] += imos[i][j]
for i in range(q):
l, r = list(map(int, input().split()))
l -= 1
r -= 1
if l == 0:
print((imos[r][r]))
else:
print((imos[r][r] - imos[l - 1][r] - imos[r][l - 1] + imos[l - 1][l - 1]))
| p03283 |
#横にn個入力
n, m, q = list(map(int, input().split()))
#行列
s = []
for i in range(m):#h:高さ
s.append([int(m) for m in input().split()] + [i])
# 行列
t = []
for i in range(q): # h:高さ
t.append([int(m) for m in input().split()])
lin = []
li0 = []
for i in range(n):
lin.append(set())
li0.append(set())
for i in range(m):
lin[s[i][0] - 1].add(s[i][2])
li0[s[i][1] - 1].add(s[i][2])
for i in range(n - 1):
li0[i + 1] = li0[i + 1] | li0[i]
for i in range(n - 1, 0, -1):
lin[i - 1] = lin[i] | lin[i - 1]
for i in range(q):
ans = len(lin[t[i][0] - 1] & li0[t[i][1] - 1])
print(ans) | #横にn個入力
n, m, q = list(map(int, input().split()))
#行列
s = []
for i in range(m):#h:高さ
s.append([int(m) for m in input().split()] + [i])
# 行列
t = []
for i in range(q): # h:高さ
t.append([int(m) for m in input().split()])
LR = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
for v in range(m):
LR[s[v][0]][s[v][1]] += 1
for j in range(1, n + 1):
for i in range(1, n + 1):#Lについての累積和
LR[i][j] += LR[i - 1][j]
for k in range(q):
tmp = 0
for j in range(t[k][0], t[k][1] + 1):#Rについてみていく
tmp += LR[t[k][1]][j] - LR[t[k][0] - 1][j]
print(tmp) | p03283 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, M, Q = MAP()
LR = [LIST() for _ in range(M)]
pq = [LIST() for _ in range(Q)]
x = [[0]*(N+1) for _ in range(N+1)]
for L, R in LR:
x[L][R] += 1
for l in range(N+1):
x[l] = list(accumulate(x[l]))
for p, q in pq:
ans = 0
for i in range(p, q+1):
ans += x[i][q] - x[i][p-1]
print(ans)
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N, M, Q = MAP()
LR = [LIST() for _ in range(M)]
pq = [LIST() for _ in range(Q)]
x = [[0]*(N+1) for _ in range(N+1)]
for L, R in LR:
x[L][R] += 1
for l in range(N+1):
x[l] = list(accumulate(x[l]))
for l in range(1, N+1):
for r in range(N+1):
x[l][r] += x[l-1][r]
for p, q in pq:
print((x[q][q] - x[q][p-1] - x[p-1][q] + x[p-1][p-1]))
| p03283 |
from bisect import bisect
n,m,q=(int(i) for i in input().strip().split(" "))
from collections import defaultdict
d=defaultdict(list)
for _ in range(m):
a,b=(int(i) for i in input().strip().split(" "))
d[a].append(b)
for i in list(d.keys()):
d[i].sort()
for i in range(q):
l,r=(int(i) for i in input().strip().split(" "))
c=0
for j in range(l,r+1):
c+=bisect(d[j],r)
c-=bisect(d[j],l-1)
print(c)
|
n,m,q=(int(i) for i in input().strip().split(" "))
from collections import defaultdict
d=defaultdict(int)
for _ in range(m):
a,b=(int(i) for i in input().strip().split(" "))
d[(a,b)]+=1
for i in range(1,n+1):
for j in range(1,n+1):
d[(i,j)]+=d[(i,j-1)]
for i in range(1,n+1):
for j in range(1,n+1):
d[(i,j)]+=d[(i-1,j)]
for i in range(q):
l,r = (int(i) for i in input().strip().split(" "))
print((d[(r,r)]+d[(l-1,l-1)]-d[(l-1,r)]-d[(r,l-1)]))
| p03283 |
num_city, num_train, num_question = [int(i) for i in input().split()]
#電車の数
trains = [[0] * (num_city + 1) for i in range(0, num_city + 1)]
for i in range(0, num_train):
start, arrive = [int(j) for j in input().split()]
trains[start][arrive] += 1
#累積和表を作る
trains_cumulative_sum = [[0] * (num_city + 1) for i in range(0, num_city + 1)]
for start in range(0, num_city + 1):
for arrive in range(0, num_city + 1):
trains_cumulative_sum[start][arrive] = trains_cumulative_sum[start][arrive - 1] + trains[start][arrive]
for i in range(0, num_question):
start, arrive = [int(j) for j in input().split()]
result = 0
for j in range(start, arrive + 1):
result += trains_cumulative_sum[j][arrive]
print(result)
| num_city, num_train, num_question = [int(i) for i in input().split()]
#電車の数
trains = [[0] * (num_city + 1) for i in range(0, num_city + 1)]
for i in range(0, num_train):
start, arrive = [int(j) for j in input().split()]
trains[start][arrive] += 1
#累積和表を作る
cumlative_sum = [[0] * (num_city + 1) for i in range(0, num_city + 1)]
for start in range(0, num_city + 1):
for arrive in range(0, num_city + 1):
cumlative_sum[start][arrive] = cumlative_sum[start][arrive - 1] + trains[start][arrive]
for start in range(0, num_city + 1):
for arrive in range(0, num_city + 1):
cumlative_sum[start][arrive] += cumlative_sum[start - 1][arrive]
for i in range(0, num_question):
start, arrive = [int(j) for j in input().split()]
result = cumlative_sum[arrive][arrive] - cumlative_sum[start - 1][arrive] - cumlative_sum[arrive][start - 1] + cumlative_sum[start - 1][start - 1]
print(result)
| p03283 |
# D - AtCoder Express 2
# https://atcoder.jp/contests/abc106/tasks/abc106_d
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline() for _ in range(n)]
ii2nnn = lambda n: ss2nnn(ii2ss(n))
# N 個の都市
# M 本の列車
# Q 個の興味
def main_lte(N, M, Q, LRm, PQq):
for p, q in PQq:
ans = 0
for l, r in LRm:
if p <= l and r <= q:
ans += 1
print(ans)
def main_lte2(N, M, Q, LRm, PQq):
table = [[0] * (N+1) for _ in range(N+1)]
for l, r in LRm:
table[l][r] += 1
for p, q in PQq:
ans = 0
for i in range(p, q+1):
for j in range(i, q+1):
ans += table[i][j]
print(ans)
def main(N, M, Q, LRm, PQq):
table = [[0] * (N+1) for _ in range(N+1)]
for l, r in LRm:
table[l][r] += 1
# 累積輪
table2 = [[0] * (N+1) for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
table2[i][j] = table2[i][j-1] + table[i][j]
for p, q in PQq:
ans = 0
for i in range(p, q+1):
ans += table2[i][q] - table2[i][p-1]
print(ans)
N, M, Q = i2nn()
LRm = ii2nnn(M)
PQq = ii2nnn(Q)
main(N, M, Q, LRm, PQq)
| # D - AtCoder Express 2
# https://atcoder.jp/contests/abc106/tasks/abc106_d
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline() for _ in range(n)]
ii2nnn = lambda n: ss2nnn(ii2ss(n))
# N 個の都市
# M 本の列車
# Q 個の興味
def main_lte(N, M, Q, LRm, PQq):
for p, q in PQq:
ans = 0
for l, r in LRm:
if p <= l and r <= q:
ans += 1
print(ans)
def main_lte2(N, M, Q, LRm, PQq):
table = [[0] * (N+1) for _ in range(N+1)]
for l, r in LRm:
table[l][r] += 1
for p, q in PQq:
ans = 0
for i in range(p, q+1):
for j in range(i, q+1):
ans += table[i][j]
print(ans)
def main_lte3(N, M, Q, LRm, PQq):
table = [[0] * (N+1) for _ in range(N+1)]
for l, r in LRm:
table[l][r] += 1
# 累積輪
table2 = [[0] * (N+1) for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
table2[i][j] = table2[i][j-1] + table[i][j]
for p, q in PQq:
ans = 0
for i in range(p, q+1):
ans += table2[i][q] - table2[i][p-1]
print(ans)
def main(N, M, Q, LRm, PQq):
table = [[0] * (N+1) for _ in range(N+1)]
for l, r in LRm:
table[l][r] += 1
# 二次元累積輪
for i in range(1, N+1):
for j in range(1, N+1):
table[i][j] += table[i][j-1]
for i in range(1, N+1):
for j in range(1, N+1):
table[i][j] += table[i-1][j]
for p, q in PQq:
ans = table[q][q] + table[p-1][p-1] - table[p-1][q] - table[q][p-1]
print(ans)
N, M, Q = i2nn()
LRm = ii2nnn(M)
PQq = ii2nnn(Q)
main(N, M, Q, LRm, PQq)
| p03283 |
N, M, Q = list(map(int,input().split()))
m = [[0 for y in range(N+1)] for x in range(N+1)]
m2 = [[0 for y in range(N+1)] for x in range(N+1)]
for i in range(M):
l, r = list(map(int,input().split()))
m[l][r]+=1
for i in range(1,N+1):
s=m[i][i]
m2[i][i]=s
for j in range(i+1,N+1):
for k in range(i,j+1):
s+=m[k][j]
m2[i][j]=s
for i in range(1,Q+1):
l, r = list(map(int,input().split()))
print((m2[l][r]))
| N, M, Q = list(map(int,input().split()))
m = [[0 for y in range(N+1)] for x in range(N+1)]
m2 = [[0 for y in range(N+1)] for x in range(N+1)]
m3 =[[0 for y in range(N+1)] for x in range(N+1)]
for i in range(M):
l, r = list(map(int,input().split()))
m[l][r]+=1
for j in range(1, N+1):
s=0
for i in range(1, N+1):
s+=m[i][j]
m2[i][j]=s
for i in range(1, N+1):
s=0
for j in range(i, N+1):
s+=m2[j][j]-m2[i-1][j]
m3[i][j]=s
for i in range(1,Q+1):
l, r = list(map(int,input().split()))
print((m3[l][r]))
| p03283 |
n, m, q = list(map(int, input().split()))
Arr = []
for i in range(n+1):
Arr.append([0] * (n+1))
for i in range(m):
l, r = list(map(int, input().split()))
Arr[l][r] += 1
#print(Arr)
for i in range(q):
left, right = list(map(int, input().split()))
train_num = 0
for j in range(left, right+1):
for k in range(left, right+1):
train_num += Arr[j][k]
print(train_num) | n, m, q = list(map(int, input().split()))
Arr = []
for i in range(n+1):
Arr.append([0] * (n+1))
for i in range(m):
l, r = list(map(int, input().split()))
Arr[l][r] += 1
#print(Arr)
B = []
for i in range(n+1):
B_line = [0]
for j in range(1, n+1):
B_line.append(B_line[-1] + Arr[i][j])
B.append(B_line)
#print(B)
for x in range(q):
left, right = list(map(int, input().split()))
train_num = 0
for i in range(left, right+1):
train_num += B[i][right] - B[i][left-1]
print(train_num) | p03283 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class SegmentTree():
# to par: (n-1) // 2
# to chr: 2n+1, 2n+2
def __init__(self, N):
self.__N = 2**int(math.ceil(math.log(N, 2)))
self.__table = [set([]) for _ in range(self.__N * 2 - 1)]
def update(self, idx, x):
i = self.__N - 1 + idx # target leaf
self.__table[i].add(x)
while i != 0:
pi = (i - 1) // 2 # parent
self.__table[pi].add(x)
# if self.__table[i] < self.__table[pi]:
# self.__table[pi] = self.__table[i]
# else:
# break
i = pi
def __query(self, a, b, k, l, r):
if r <= a or b <= l:
return set([])
if a <= l and r <= b:
return self.__table[k]
vl = self.__query(a, b, 2 * k + 1, l, (l + r) // 2)
vr = self.__query(a, b, 2 * k + 2, (l + r) // 2, r)
return vl | vr
def query(self, a, b):
return self.__query(a, b, 0, 0, self.__N)
def print(self):
print(self.__table)
@mt
def slv(N, M, Q, LR, PQ):
st = SegmentTree(N+1)
for i, (l, r) in enumerate(LR):
st.update(l, ('s', i))
st.update(r, ('e', i))
for p, q in PQ:
l = st.query(p, q+1)
n = len(l)
m = len(set(map(lambda x: x[1], l)))
print(n-m)
def main():
N, M, Q = read_int_n()
LR = [read_int_n() for _ in range(M)]
PQ = [read_int_n() for _ in range(Q)]
slv(N, M, Q, LR, PQ)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class RectangleSum():
def __init__(self, N, M):
self.N = N
self.M = M
self.s = [[0] * (M+1) for _ in range(N+1)]
def add(self, i, j, v):
self.s[i+1][j+1] += v
def build(self):
for i in range(self.N+1):
for j in range(self.M):
self.s[i][j+1] += self.s[i][j]
for i in range(self.N):
for j in range(self.M+1):
self.s[i+1][j] += self.s[i][j]
def sum(self, i, j, h, w):
ret = self.s[i][j]
ret += self.s[i+h][j+w]
ret -= self.s[i+h][j]
ret -= self.s[i][j+w]
return ret
@mt
def slv(N, M, Q, LR, PQ):
rs = RectangleSum(N+1, N+1)
for l, r in LR:
rs.add(l, r, 1)
rs.build()
for p, q in PQ:
print(rs.sum(p, p, q-p+1, q-p+1))
def main():
N, M, Q = read_int_n()
LR = [read_int_n() for _ in range(M)]
PQ = [read_int_n() for _ in range(Q)]
slv(N, M, Q, LR, PQ)
if __name__ == '__main__':
main()
| p03283 |
N, M, Q = list(map(int, input().split()))
Mi = [list(map(int, input().split())) for i in range(M)]
Qi = [list(map(int, input().split())) for i in range(Q)]
qi = [Qi[i].extend([0, i]) for i in range(Q)]
Mi.sort()
Qi.sort()
for mi in Mi:
for i in range(Q):
if mi[0] < Qi[i][0]:
continue
if mi[0] >= Qi[i][0] and mi[1] <= Qi[i][1]:
Qi[i][2] += 1
Qi.sort(key=lambda x: x[3])
for a in Qi:
print((a[2])) | N, M, Q = list(map(int, input().split()))
LR = [[0] * (N+1) for _ in range(N+1)]
for m in range(M):
l, r = list(map(int, input().split()))
LR[l][r] += 1
# 二次元累積和をとる
LR_sum = [[0] * (N+1) for _ in range(N+1)]
LR_sum[1][1] = LR[1][1]
## 初期化
for i in range(1, N+1):
LR_sum[1][i] = LR_sum[1][i-1] + LR[1][i]
LR_sum[i][1] = LR_sum[i-1][1] + LR[i][1]
## 累積和をとる
for i in range(2, N+1):
for j in range(2, N+1):
LR_sum[i][j] = LR_sum[i-1][j] + LR_sum[i][j-1] - LR_sum[i-1][j-1] + LR[i][j]
for q in range(Q):
l, r = list(map(int, input().split()))
print((LR_sum[r][r] - LR_sum[r][l-1] - LR_sum[l-1][r] + LR_sum[l-1][l-1]))
| p03283 |
N,M,Q = list(map(int, input().split()))
LR = [list(map(int, input().split())) for i in range(M)]
pq = [list(map(int, input().split())) for i in range(Q)]
res = [[0]*N for i in range(N)]
def lsadd(L,R):
L-=1
R-=1
for i in range(0,L+1):
for j in range(R,N):
res[i][j] += 1
for l,r in LR:
lsadd(l,r)
for p,q in pq:
print((res[p-1][q-1]))
| N,M,Q = list(map(int, input().split()))
LR = [list(map(int, input().split())) for i in range(M)]
pq = [list(map(int, input().split())) for i in range(Q)]
res = [[0]*N for i in range(N)]
def lsadd(L,R):
L-=1
R-=1
for i in range(0,L+1):
res[i][R] += 1
for l,r in LR:
lsadd(l,r)
for p,q in pq:
print((sum(res[p-1][:q])))
| p03283 |
from itertools import accumulate
n, m, q = list(map(int, input().split()))
rails = [[0] * n for _ in range(n)]
for _ in range(m):
l, r = list(map(int, input().split()))
rails[l - 1][r - 1] += 1
rails = [list(accumulate(s)) for s in rails]
rails = [list(reversed(list(accumulate(reversed(s))))) for s in zip(*rails)]
buf = []
for _ in range(q):
p, q = list(map(int, input().split()))
buf.append(rails[q - 1][p - 1])
print(('\n'.join(map(str, buf))))
| import sys
from itertools import accumulate
n, m, q = list(map(int, input().split()))
ipt = sys.stdin.readlines()
rails = [[0] * n for _ in range(n)]
for l, r in (list(map(int, line.split())) for line in ipt[:m]):
rails[l - 1][r - 1] += 1
rails = [list(reversed(list(accumulate(reversed(s))))) for s in zip(*(accumulate(s) for s in rails))]
print(('\n'.join(str(rails[q - 1][p - 1]) for p, q in (list(map(int, line.split())) for line in ipt[m:]))))
| p03283 |
import sys
from itertools import accumulate
n, m, q = list(map(int, input().split()))
ipt = sys.stdin.readlines()
rails = [[0] * n for _ in range(n)]
for l, r in (list(map(int, line.split())) for line in ipt[:m]):
rails[l - 1][r - 1] += 1
rails = [list(reversed(list(accumulate(reversed(s))))) for s in zip(*(accumulate(s) for s in rails))]
print(('\n'.join(str(rails[q - 1][p - 1]) for p, q in (list(map(int, line.split())) for line in ipt[m:]))))
| import sys
from itertools import accumulate, islice
n, m, q = list(map(int, input().split()))
ipt = (list(map(int, line.split())) for line in sys.stdin.readlines())
rails = [[0] * n for _ in range(n)]
for l, r in islice(ipt, m):
rails[l - 1][r - 1] += 1
rails = [list(accumulate(reversed(s))) for s in zip(*(accumulate(s) for s in rails))]
print(('\n'.join(str(rails[q - 1][n - p]) for p, q in ipt)))
| p03283 |
import sys
from itertools import accumulate, islice
n, m, q = list(map(int, input().split()))
ipt = (list(map(int, line.split())) for line in sys.stdin.readlines())
rails = [[0] * n for _ in range(n)]
for l, r in islice(ipt, m):
rails[l - 1][r - 1] += 1
rails = [list(accumulate(reversed(s))) for s in zip(*(accumulate(s) for s in rails))]
print(('\n'.join(str(rails[q - 1][n - p]) for p, q in ipt)))
| import sys
from itertools import accumulate, islice
n, m, q = list(map(int, input().split()))
ipt = (list(map(int, line.split())) for line in sys.stdin.readlines())
rails = [[0] * n for _ in range(n)]
for l, r in islice(ipt, m):
rails[l - 1][r - 1] += 1
rails = [list(accumulate(reversed(s))) for s in zip(*(accumulate(s) for s in rails))]
print(('\n'.join(map(str, (rails[q - 1][n - p] for p, q in ipt)))))
| p03283 |
import bisect
N,M,Q=list(map(int,input().split()))
Rli=[[] for _ in range(N)]
for i in range(M):
l,r=list(map(int,input().split()))
Rli[l-1].append(r)
for i in range(N):
Rli[i].sort()
for i in range(Q):
ans=0
p,q=list(map(int,input().split()))
for j in range(p-1,N):
ans+=bisect.bisect_right(Rli[j],q)
print(ans) | import bisect
N,M,Q=list(map(int,input().split()))
LR=[[0]*(N+1) for _ in range(N)]
for i in range(M):
l,r=list(map(int,input().split()))
LR[l-1][r]+=1
for i in range(N):
for j in range(1,N+1):
LR[i][j]+=LR[i][j-1]
for _ in range(Q):
ans=0
p,q=list(map(int,input().split()))
for i in range(p-1,q):
ans+=LR[i][q]-LR[i][p-1]
print(ans) | p03283 |
# 累積和
# PyPy なら通る
N, M, Q = list(map(int, input().split()))
t = [[0] * (N + 1) for _ in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
t[L][R] += 1
for i in range(N + 1):
for j in range(N):
t[i][j + 1] += t[i][j]
result = []
for _ in range(Q):
p, q = list(map(int, input().split()))
result.append(sum(t[i][q] - t[i][i - 1] for i in range(p, q + 1)))
print(('\n'.join(str(v) for v in result)))
#print(*result, sep='\n')
| # 累積和
# PyPy なら通る
N, M, Q = map(int, input().split())
t = [[0] * (N + 1) for _ in range(N + 1)]
for _ in range(M):
L, R = map(int, input().split())
t[L][R] += 1
for i in range(N + 1):
for j in range(N):
t[i][j + 1] += t[i][j]
result = []
for _ in range(Q):
p, q = map(int, input().split())
result.append(sum(t[i][q] - t[i][i - 1] for i in range(p, q + 1)))
#print('\n'.join(str(v) for v in result))
print(*result, sep='\n')
| p03283 |
from bisect import bisect_left
n,m,q=list(map(int,input().split())) #0-indexed
tree=[[] for i in range(n)]
lentree=[0]*n
for i in range(m):
l,r=list(map(int,input().split()))
tree[l-1].append(r-1)
for i in range(n):
if tree[i]!=[]:
tree[i].sort()
for i in range(n):
lentree[i]+=len(tree[i])
for i in range(q):
l,r=list(map(int,input().split()))
l-=1
r-=1
ans=0
for j in range(l,r+1):
xxx=tree[j]
ans+=bisect_left(xxx,r+1)
print(ans) | import itertools
n,m,q=list(map(int,input().split())) #0-indexed
LR=[[0]*(n+1) for i in range(n+1)]
for i in range(m):
l,r=list(map(int,input().split()))
LR[l][r]+=1
for i in range(n):
LR[i]=list(itertools.accumulate(LR[i]))
for i in range(q):
l,r=list(map(int,input().split()))
ans=0
for j in range(l,r+1):
ans+=LR[j][r]-LR[j][l-1]
print(ans) | p03283 |
# https://atcoder.jp/contests/abc106/tasks/abc106_d
'''
N が小さいので、N^2 を考えると良いことが分かる。
'''
from collections import defaultdict
N, M, Q = list(map(int, input().split())) # N, M: リストの長さ
edges = [list(map(int, input().split())) for _ in range(M)]
data = defaultdict(int) # defaultdict は 初期化の際のに value の type を指定する必要あり
for i, j in edges:
i -= 1
j -= 1
data[(i,j)] += 1
cum = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N):
cum[i+1][j+1] = cum[i][j+1] + cum[i+1][j] - cum[i][j] + data[(i,j)]
for _ in range(Q):
p, q = list(map(int, input().split()))
if p < q:
p, q = q, p
q -= 1
res = cum[p][p] - cum[p][q] - cum[q][p] + cum[q][q]
print(res)
| N, M, Q = list(map(int, input().split()))
C = [[0]*N for _ in range(N)]
for _ in range(M):
L, R = list(map(int, input().split()))
C[L-1][R-1] += 1
S = [[0]*(N+1) for _ in range(N+1)]
for r in range(N):
for l in reversed(list(range(N))):
S[l][r] = S[l+1][r] + C[l][r]
D = [[0]*(N+1) for _ in range(N+1)]
for l in range(N):
for r in range(N):
D[l][r] = D[l][r-1] + S[l][r]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((D[p-1][q-1]))
| p03283 |
def main():
import sys
input = sys.stdin.readline
n,m,q = list(map(int,input().split()))
l = [[0]*(n) for i in range(n)]
for i in range(m):
a,b = list(map(int,input().split()))
l[a-1][b-1] += 1
for i in range(q):
a,b = list(map(int,input().split()))
count = 0
for i in range(a-1,b):
for j in range(a-1,b):
count += l[i][j]
print(count)
if __name__ == "__main__":
main() | n,m,q = list(map(int,input().split()))
l = [[0]*(n) for i in range(n)]
for i in range(m):
a,b = list(map(int,input().split()))
l[a-1][b-1] += 1
for i in range(n):
for j in range(n):
if i != 0:
l[i][j] += l[i-1][j]
if j != 0:
l[i][j] += l[i][j-1]
if i!= 0 and j != 0:
l[i][j] -= l[i-1][j-1]
for i in range(q):
a,b = list(map(int,input().split()))
ans = l[b-1][b-1]
if a >= 2:
ans -= l[a-2][b-1]
print(ans) | p03283 |
N, M, Q = list(map(int, input().split()))
count = [[0] * N for i in range(N)]
for _ in range(M):
L,R = list(map(int, input().split()))
for i in range(0,L):
for j in range(R-1,N):
count[i][j] += 1
for _ in range(Q):
p,q = list(map(int, input().split()))
print((count[p-1][q-1]))
| N, M, Q = list(map(int, input().split()))
count = [[0] * (N+1) for i in range(N)]
for _ in range(M):
L,R = list(map(int, input().split()))
count[L-1][R] += 1
for i in range(N):
for j in range(1,N+1):
count[i][j] += count[i][j-1]
for _ in range(Q):
p,q = list(map(int, input().split()))
ans = 0
for i in range(p-1,q):
ans += count[i][q] - count[i][p-1]
print(ans) | p03283 |
N,M,Q=list(map(int,input().split()))
cumsum = [[0] * (N+1) for _ in range(N+1)]
for _ in range(M):
L,R=list(map(int,input().split()))
cumsum[L][R] += 1
for i in range(1,N+1):
for j in range(1,N+1):
cumsum[i][j] += cumsum[i-1][j] + cumsum[i][j-1] - cumsum[i-1][j-1]
for _ in range(Q):
p,q = list(map(int,input().split()))
ans = cumsum[q][q]-cumsum[p-1][q]-cumsum[q][p-1]+cumsum[p-1][p-1]
print(ans) | N,M,Q=list(map(int,input().split()))
table = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L,R=list(map(int,input().split()))
table[L][R] += 1
for i in range(1,N+1):
for j in range(1,N+1):
table[i][j] += table[i-1][j] + table[i][j-1] - table[i-1][j-1]
for _ in range(Q):
p,q = list(map(int,input().split()))
print((table[q][q] - table[q][p-1] - table[p-1][q] + table[p-1][p-1]))
| p03283 |
from itertools import accumulate
N,M,Q=list(map(int,input().split()))
Station=[[0 for x in range(N+2)] for y in range(N+2)]
for i in range(M):
s,t=list(map(int,input().split()))
Station[1][t]+=1
Station[s+1][t]-=1
Station[1][N+1]+=1
Station[s+1][N+1]-=1
ST1 = [list(accumulate(l)) for l in zip(*Station)]
ST2 = [list(accumulate(l)) for l in zip(*ST1)]
for i in range(Q):
l,r=list(map(int,input().split()))
print((ST2[l][r]))
| from itertools import accumulate
N,M,Q=list(map(int,input().split()))
Station=[[0 for x in range(N+2)] for y in range(N+2)]
for i in range(M):
s,t=list(map(int,input().split()))
Station[1][t]+=1
Station[s+1][t]-=1
Station[1][N+1]+=1
Station[s+1][N+1]-=1
ST1 = [list(accumulate(l)) for l in zip(*Station)]
ST2 = [list(accumulate(l)) for l in zip(*ST1)]
for i in range(Q):
l,r=list(map(int,input().split()))
print((ST2[l][r]))
| p03283 |
n, m, Q = list(map(int, input().split()))
ts = [[0] * (n+1) for _ in range(n+1)]
for _ in range(m):
l, r = tuple(map(int, input().split()))
ts[l][r] += 1
from itertools import accumulate
tsa = [list(accumulate(t)) for t in ts]
for _ in range(Q):
p, q = tuple(map(int, input().split()))
c = 0
for i in range(p, q+1):
c += tsa[i][q] - tsa[i][p-1]
print(c) | n, m, Q = list(map(int, input().split()))
ts = [[0] * (n+1) for _ in range(n+1)]
for _ in range(m):
l, r = tuple(map(int, input().split()))
ts[l][r] += 1
# 二次元累積和
for i in range(1, n+1):
for j in range(1, n+1):
ts[i][j] += ts[i][j-1]
for i in range(1, n+1):
for j in range(1, n+1):
ts[i][j] += ts[i-1][j]
for _ in range(Q):
p, q = tuple(map(int, input().split()))
print((ts[q][q] - ts[p-1][q] - ts[q][p-1] + ts[p-1][p-1]))
| p03283 |
N, M, Q = list(map(int, input().split()))
train = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M) :
L, R = list(map(int, input().split()))
train[L][R] += 1
que = []
for _ in range(Q) :
p, q = list(map(int, input().split()))
que.append((p, q))
# 累積和
S = [[0 for _ in range(N+1)] for _ in range(N+1)] # ゼロパディング
for l in range(1, N+1) :
for r in range(1, N+1) :
S[l][r] = S[l-1][r] + S[l][r-1] - S[l-1][r-1] + train[l][r]
for p, q in que :
ans = S[q][q] - S[p-1][q] - S[q][p-1] + S[p-1][p-1]
print(ans) | N, M, Q = map(int, input().split())
LR = [[0] * (N + 1) for _ in range(N + 1)]
for _ in range(M):
L, R = map(int, input().split())
LR[L][R] += 1
for l in range(1, N + 1):
for r in range(1, N + 1):
LR[l][r] = LR[l - 1][r] + LR[l][r - 1] - LR[l - 1][r - 1] + LR[l][r]
ans = []
for _ in range(Q):
p, q = map(int, input().split())
cnt = LR[q][q] - LR[q][p - 1] - LR[p - 1][q] + LR[p - 1][p - 1]
ans.append(cnt)
print(*ans, sep='\n')
| p03283 |
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
ips = lambda:input().split()
import collections
import math
import itertools
import heapq as hq
n,m,q = ma()
L_rs=[[] for i in range(n)]
for i in range(m):
l,r=ma()
L_rs[l-1].append(r-1)
for i in range(n):
L_rs[i].sort()
# print(L_rs)
def isok(num,val):##適宜変更
return num<=val
def bisect(ls,val): ##valの関数isok(x,val)がTrueとなる一番右のindex を返す 全部Falseなら-1,Trueならlen(ls)-1
ok = -1
ng = len(ls)
x = (ok+ng)//2
while ng-ok>1:
num = ls[x]
if isok(num,val):
ok = x
else:
ng = x
x = (ok+ng)//2
return ok ##一番右のTrueのindex Trueの個数はok+1こ
def solve(L,R):##0idx
ret=0
for l in range(L,R+1):
ret+=bisect(L_rs[l],R)+1
return ret
ans = [[0]*n for i in range(n)]
for l in range(n):
for r in range(n):
ans[l][r]=solve(l,r)
for i in range(q):
l,r=ma()
print(ans[l-1][r-1])
| ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
ips = lambda:input().split()
import collections
import math
import itertools
import heapq as hq
n,m,q = ma()
L_rs=[[] for i in range(n)]
for i in range(m):
l,r=ma()
L_rs[l-1].append(r-1)
for i in range(n):
L_rs[i].sort()
# print(L_rs)
def isok(num,val):##適宜変更
return num<=val
def bisect(ls,val): ##valの関数isok(x,val)がTrueとなる一番右のindex を返す 全部Falseなら-1,Trueならlen(ls)-1
ok = -1
ng = len(ls)
x = (ok+ng)//2
while ng-ok>1:
num = ls[x]
if isok(num,val):
ok = x
else:
ng = x
x = (ok+ng)//2
return ok ##一番右のTrueのindex Trueの個数はok+1こ
ans = [[0]*(n+1) for i in range(n+1)]
for r in range(n):
for l in range(r,-1,-1):
ans[l][r]=ans[l+1][r] + bisect(L_rs[l],r)+1
for i in range(q):
l,r=ma()
print(ans[l-1][r-1])
| p03283 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
a, b = LI()
print(((a-1)*(b-1)))
return
#B
def B():
def est(n):
res = 0
for i in range(1, int(n ** 0.5) + 1):
if not n % i:
res += 2
res -= float.is_integer(n ** 0.5)
return res == 8
n = II()
ans = 0
for i in range(1, n + 1, 2):
ans += est(i)
print(ans)
return
#C
def C():
s = S()
k = II()
for i in range(k):
if s[i] != "1":
print((s[i]))
return
print((s[k-1]))
return
# D
# 解説AC
# 始点と終点を2次元座標に落とし込むことで解ける
# 難しい
def D():
n, m, q = LI()
c = [[0] * n for i in range(n)]
for _ in range(m):
l, r = LI_()
c[l][r] += 1
for _ in range(q):
p, q = LI_()
ans = 0
for pi in range(p, q + 1):
cpi = c[pi]
for qi in range(p, q + 1):
ans += cpi[qi]
print(ans)
return
#Solve
if __name__ == '__main__':
D()
| #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
a, b = LI()
print(((a-1)*(b-1)))
return
#B
def B():
def est(n):
res = 0
for i in range(1, int(n ** 0.5) + 1):
if not n % i:
res += 2
res -= float.is_integer(n ** 0.5)
return res == 8
n = II()
ans = 0
for i in range(1, n + 1, 2):
ans += est(i)
print(ans)
return
#C
def C():
s = S()
k = II()
for i in range(k):
if s[i] != "1":
print((s[i]))
return
print((s[k-1]))
return
# D
# 解説AC
# 始点と終点を2次元座標に落とし込むことで解ける
# 難しい
def D():
n, m, q = LI()
c = [[0] * n for i in range(n)]
for _ in range(m):
l, r = LI_()
c[r][l] += 1
for y in range(n):
for x in range(1, n):
c[y][x] += c[y][x - 1]
for _ in range(q):
p, q = LI_()
ans = 0
for qi in range(p, q + 1):
ans += c[qi][q] - (c[qi][p - 1] if p != 0 else 0)
print(ans)
return
#Solve
if __name__ == '__main__':
D()
| p03283 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.