input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
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)]
def rectangle_sum(n):
table = [[0 for _ in range(n)] for _ in range(n)]
for l, r in LR:
table[l - 1][r - 1] += 1
for y in range(N):
for x in range(1, N):
table[y][x] += table[y][x - 1]
for y in range(1, N):
for x in range(N):
table[y][x] += table[y - 1][x]
return table
t = rectangle_sum(N)
for p, q in PQ:
if p - 2 >= 0:
tmp = t[q - 1][q - 1] - t[q - 1][p - 2] - t[p - 2][q - 1] + t[p - 2][p - 2]
else:
tmp = t[q - 1][q - 1]
print(tmp) | 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)]
def rectangle_sum(n):
table = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
for l, r in LR:
table[l][r] += 1
for y in range(n + 1):
for x in range(1, n + 1):
table[y][x] += table[y][x - 1]
for y in range(1, n + 1):
for x in range(n + 1):
table[y][x] += table[y - 1][x]
return table
t = rectangle_sum(N)
for p, q in PQ:
tmp = t[q][q] - t[q][p - 1] - t[p - 1][q] + t[p - 1][p - 1]
print(tmp) | p03283 |
n,m,q = list(map(int,input().split()))
table = []
res = []
for i in range(n+1):
table.append([0]*(i+1))
res.append([0]*(i+1))
for i in range(m):
a,b = list(map(int,input().split()))
table[b][a] += 1
for begin in range(1,n+1):
s = 0
for ending in range(begin,n+1):
for k in range(begin,ending+1):
s += table[ending][k]
res[ending][begin] = s
for _ in range(q):
start,end = list(map(int,input().split()))
print((res[end][start]))
| n,m,q = list(map(int,input().split()))
table = []
for i in range(n+1):
table.append([0]*(n+1))
for i in range(m):
a,b = list(map(int,input().split()))
table[b][a] += 1
#2...n
for i in range(2,n+1):
#1...n-1
for j in range(1,n+2-i):
table[i+j-1][j] += table[i+j-1][j+1]+table[i+j-2][j]-table[i+j-2][j+1]
for _ in range(q):
start,end = list(map(int,input().split()))
print((table[end][start]))
| p03283 |
N, M , Q = list(map(int, input().split()))
LR = [[0 for _ in range(N+2-i)] for i in range(N+2)]
for i in range(M):
L, R = list(map(int, input().split()))
LR[L][R-L+1] += 1
for i in range(2,N+2):
for j in range(1,N-i+2):
LR[j][i] += LR[j][i-1] + LR[j+1][i-1] - LR[j+1][i-2]
for i in range(Q):
p, q = list(map(int, input().split()))
print((LR[p][q-p+1]-LR[q+1][0]))
| N, M , Q = list(map(int, input().split()))
LR = [[0 for _ in range(N+2-i)] for i in range(N+2)]
for i in range(M):
L, R = list(map(int, input().split()))
LR[L][R-L+1] += 1
for i in range(2,N+2):
for j in range(1,N-i+2):
LR[j][i] += LR[j][i-1] + LR[j+1][i-1] - LR[j+1][i-2]
A = []
for i in range(Q):
p, q = list(map(int, input().split()))
A.append(LR[p][q-p+1]-LR[q+1][0])
print(("\n".join(map(str,A))))
| p03283 |
N, M , Q = list(map(int, input().split()))
LR = [[0 for _ in range(N+2-i)] for i in range(N+2)]
for i in range(M):
L, R = list(map(int, input().split()))
LR[L][R-L+1] += 1
for i in range(2,N+2):
for j in range(1,N-i+2):
LR[j][i] += LR[j][i-1] + LR[j+1][i-1] - LR[j+1][i-2]
A = []
for i in range(Q):
p, q = list(map(int, input().split()))
A.append(LR[p][q-p+1])
print(("\n".join(map(str,A))))
| import sys
sin = sys.stdin.readlines()
N, M, Q = list(map(int, sin[0].split()))
LR = [[0 for _ in range(N+2-i)] for i in range(N+2)]
for line in sin[1:M+1]:
L, R = list(map(int, line.split()))
LR[L][R-L+1] += 1
for i in range(2,N+2):
for j in range(1,N-i+2):
LR[j][i] += LR[j][i-1] + LR[j+1][i-1] - LR[j+1][i-2]
A = []
for line in sin[M+1:]:
p, q = list(map(int, line.split()))
A.append(LR[p][q-p+1])
print(("\n".join(map(str,A))))
| p03283 |
import sys
N, M, Q = list(map(int, sys.stdin.readline().split()))
LR = [[0 for _ in range(N+2-i)] for i in range(N+2)]
for i in range(M):
L, R = list(map(int, sys.stdin.readline().split()))
LR[L][R-L+1] += 1
for i in range(2,N+2):
for j in range(1,N-i+2):
LR[j][i] += LR[j][i-1] + LR[j+1][i-1] - LR[j+1][i-2]
for i in range(Q):
p, q = list(map(int, sys.stdin.readline().split()))
sys.stdout.write("{}\n".format(LR[p][q-p+1])) | import sys
N, M, Q = list(map(int, sys.stdin.readline().split()))
LR = [[0 for _ in range(N+2-i)] for i in range(N+2)]
for i in range(M):
L, R = list(map(int, sys.stdin.readline().split()))
LR[L][R-L+1] += 1
for i in range(2,N+2):
for j in range(1,N-i+2):
LR[j][i] += LR[j][i-1] + LR[j+1][i-1] - LR[j+1][i-2]
for i in range(Q):
p, q = list(map(int, sys.stdin.readline().split()))
sys.stdout.write(str(LR[p][q-p+1])+"\n") | p03283 |
import sys
from itertools import accumulate
N, M, Q = list(map(int, sys.stdin.readline().split()))
LR = [[0]* (N-i) for i in range(N)]
for i in range(M):
L, R = list(map(int, sys.stdin.readline().split()))
LR[L-1][R-L] += 1
for i in range(N-2,-1,-1):
for j, acc in enumerate(accumulate(LR[i])):
LR[i][j] = acc + (0 if j==0 else LR[i+1][j-1])
for i in range(Q):
p, q = list(map(int, sys.stdin.readline().split()))
sys.stdout.write(str(LR[p-1][q-p])+"\n") | import sys
from itertools import accumulate
N, M, Q = list(map(int, sys.stdin.readline().split()))
LR = [[0 for _ in range(N-i)] for i in range(N)]
for i in range(M):
L, R = list(map(int, sys.stdin.readline().split()))
LR[L-1][R-L] += 1
for i in range(N-2,-1,-1):
for j, acc in enumerate(accumulate(LR[i])):
LR[i][j] = acc + (0 if j==0 else LR[i+1][j-1])
for i in range(Q):
p, q = list(map(int, sys.stdin.readline().split()))
sys.stdout.write(str(LR[p-1][q-p])+"\n") | p03283 |
import sys
from itertools import accumulate
N, M, Q = list(map(int, sys.stdin.readline().split()))
LR = [[0 for _ in range(N-i)] for i in range(N)]
for i in range(M):
L, R = list(map(int, sys.stdin.readline().split()))
LR[L-1][R-L] += 1
for i in range(N-2,-1,-1):
for j, (acc, pre) in enumerate(zip(accumulate(LR[i]), [0]+LR[i+1])):
LR[i][j] = acc + pre
for i in range(Q):
p, q = list(map(int, sys.stdin.readline().split()))
sys.stdout.write(str(LR[p-1][q-p])+"\n") | import sys
from itertools import accumulate
N, M, Q = list(map(int, sys.stdin.readline().split()))
LR = [[0 for _ in range(N-i)] for i in range(N)]
for i in range(M):
L, R = list(map(int, sys.stdin.readline().split()))
LR[L-1][R-L] += 1
for i in range(N-2,-1,-1):
acc = accumulate(LR[i])
next(acc)
for j in range(1, N-i):
LR[i][j] = next(acc) + LR[i+1][j-1]
for i in range(Q):
p, q = list(map(int, sys.stdin.readline().split()))
sys.stdout.write(str(LR[p-1][q-p])+"\n") | p03283 |
#!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list([int(x)-1 for x in input().split()])
def li(): return list(eval(input()))
n, m, q = mi()
intervals = []
for _ in range(m):
l, r = mi()
intervals.append((l - 1, r))
intervals.sort(key=itemgetter(1))
commands = []
for _ in range(q):
a, b = mi()
commands.append((a - 1, b))
# completely_included[i] = ([0:i] で完全に含んでいる区間数)
completely_included = [0] * (n + 1)
for _, right in intervals:
completely_included[right] += 1
prev = 0
for i in range(1, n + 1):
completely_included[i] += prev
prev = completely_included[i]
# print(completely_included)
# across_num[r][l] = (0:right に含まれるインターバルのうち、left を内部に含むようなインターバルの個数)
across_num = [[0] * (n + 1) for _ in range(n + 1)]
for left, right in intervals:
if right - left >= 2:
for i in range(right, n + 1):
across_num[i][left + 1] += 1
across_num[i][right] -= 1
for i in range(1, n + 1):
prev = 0
for j in range(1, n + 1):
across_num[i][j] += prev
prev = across_num[i][j]
def calc_included_intervals(left, right):
return completely_included[right] - completely_included[left] - across_num[right][left]
for l, r in commands:
print((calc_included_intervals(l, r)))
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list([int(x)-1 for x in input().split()])
def li(): return list(eval(input()))
n, m, q = mi()
train = [lmi() for _ in range(m)]
query = [lmi() for _ in range(q)]
"""
電車の運行区間のうち開始地点を x 座標で、終着地点を y 座標で表し二次元座標で管理する
[i, j] 区間内で運行する電車は 0 <= x <= i, 0 <= y <= j の長方形区間内の全ての電車である
"""
coordinate = [[0] * (n + 1) for _ in range(n + 1)]
for start, end in train:
coordinate[start][end] += 1
# for line in coordinate:
# print(*line)
# print("")
# 二次元累積和に
for i in range(n):
for j in range(n):
coordinate[i+1][j+1] += coordinate[i][j+1] + coordinate[i+1][j] - coordinate[i][j]
# for line in coordinate:
# print(*line)
# print("")
# 各クエリに O(1) で答えられる！
for l, r in query:
print((coordinate[r][r] - coordinate[l-1][r] - coordinate[r][l-1] + coordinate[l-1][l-1]))
if __name__ == "__main__":
main()
| p03283 |
def m():
n, M, Q = list(map(int, input().split()))
a = [[0 for _ in range(n+1)] for _ in range(n+1)]
for i in range(M):
l, r = list(map(int, input().split()))
a[l][r] += 1
for i in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for j in range(p, q+1):
for k in range(p, q + 1):
ans += a[j][k]
print(ans)
m() | def m():
n, M, Q = list(map(int, input().split()))
a = [[0 for _ in range(n+1)] for _ in range(n+1)]
b = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(M):
l, r = list(map(int, input().split()))
a[l][r] += 1
for i in range(1, n+1):
b[1][i] += a[1][i] + b[1][i-1]
for i in range(2, n+1):
b[i][1] += a[i][1] + b[i-1][1]
for i in range(1, n+1):
for j in range(1, n+1):
b[i][j] = a[i][j] + b[i-1][j] + b[i][j-1] - b[i-1][j-1]
for i in range(Q):
p, q = list(map(int, input().split()))
ans = b[q][q] + b[p-1][p-1] - b[q][p-1] - b[p-1][q]
print(ans)
m() | p03283 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
from bisect import bisect_right
N,M,Q = II()
x = []
for i in range(M):
L,R = II()
x.append([L-1, R-1])
p,q = Line(Q)
x.sort(key = lambda x:x[1])
y = [[float('inf')]*M for _ in range(N)]
c = [0]*N
for i in range(M):
for j in range(x[i][0]+1):
y[j][c[j]] = x[i][1]
c[j] += 1
ans = 0
for i in range(Q):
print((bisect_right(y[p[i]-1], q[i]-1))) | import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
N,M,Q = II()
x = []
for i in range(M):
L,R = II()
x.append([L-1, R-1])
p = [0]*Q
q = [0]*Q
for i in range(Q):
p0,q0 = II()
p[i] = p0-1
q[i] = q0-1
a = [[0]*N for _ in range(N)]
for i in range(M):
a[x[i][0]][x[i][1]] += 1
c = [[0]*N for _ in range(N)]
for i in range(N):
for j in range(N):
if j==0:
temp = 0
else:
temp = c[i][j-1]
c[i][j] = temp + a[i][j]
for i in range(Q):
ans = 0
for j in range(p[i],q[i]+1):
ans += c[j][q[i]]
print(ans) | p03283 |
n,m,q=list(map(int,input().split()))
S=[[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()))
S[l][r]+=1
for i in range(q):
a,b=list(map(int,input().split()))
ans=0
for y in range(a,b+1):
for x in range(a,b+1):
ans+=S[x][y]
print(ans)
| n,m,q=list(map(int,input().split()))
S=[[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()))
S[l][r]+=1
for i in range(1,n+1):
for j in range(1,n):
S[i][j+1]+=S[i][j]
for i in range(q):
a,b=list(map(int,input().split()))
ans=0
for y in range(a,b+1):
ans+=S[y][b]-S[y][a-1]
print(ans)
| p03283 |
N, M, Q = [int(_) for _ in input().split()]
nl = [[0 for i in range(N)] for j in range(N)]
for t in [input().split() for _ in range(M)]:
i = int(t[0]) - 1
j = int(t[1]) - 1
nl[i][j] += 1
l = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
s = 0
for j in range(N):
l[i][j] = s + nl[i][j]
s = l[i][j]
for k in [input().split() for _ in range(Q)]:
p = int(k[0])
q = int(k[1])
ans = 0
for i in range(p-1, q):
if p == 1:
d = l[i][q-1]
else:
d = l[i][q-1] - l[i][p-2]
ans += d
print(ans) | N, M, Q = [int(_) for _ in input().split()]
l = [[0 for i in range(N+1)] for j in range(N+2)]
for t in [input().split() for _ in range(M)]:
i = int(t[0])
j = int(t[1])
l[i][j] += 1
for k in range(N):
for i in range(1, N-k+1):
j = i + k
l[i][j] += l[i][j-1] + l[i+1][j] - l[i+1][j-1]
for k in [input().split() for _ in range(Q)]:
p = int(k[0])
q = int(k[1])
print((l[p][q]))
| p03283 |
N,M,Q = list(map(int,input().split()))
LR = []
num = [[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
num[l][r] += 1
LR.append([l,r])
LR.sort()
pq = []
for i in range(Q):
p,q=list(map(int,input().split()))
p -= 1
q -= 1
ans = 0
for i in range(N-1,p-1,-1):
ans += sum(num[i][:q+1])
print(ans)
| N,M,Q = list(map(int,input().split()))
num = [[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
num[l][r] += 1
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
for i in range(N-1,0,-1):
for j in range(N):
num[i-1][j] += num[i][j]
for i in range(Q):
p,q = list(map(int,input().split()))
print((num[p-1][q-1]))
| p03283 |
N,M,Q = list(map(int,input().split()))
num = [[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
num[l][r] += 1
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
for i in range(N-1,0,-1):
for j in range(N):
num[i-1][j] += num[i][j]
for i in range(Q):
p,q = list(map(int,input().split()))
print((num[p-1][q-1]))
| N,M,Q = list(map(int,input().split()))
num = [[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
num[l][r] += 1
for i in range(N-1,0,-1):
for j in range(N):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
for i in range(Q):
p,q = list(map(int,input().split()))
print((num[p-1][q-1])) | p03283 |
N,M,Q = list(map(int,input().split()))
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int,input().split())) for i in range(M)]
for l,r in lr:
num[l-1][r-1] += 1
for j in range(N):
for i in range(N-1,0,-1):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
for i in range(Q):
p,q = list(map(int,input().split()))
print((num[p-1][q-1])) | N,M,Q = list(map(int,input().split()))
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int,input().split())) for i in range(M)]
for l,r in lr:
num[l-1][r-1] += 1
for j in range(N):
for i in range(N-1,0,-1):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
pq = [list(map(int,input().split())) for i in range(Q)]
for p,q in pq:
print((num[p-1][q-1]))
| p03283 |
N,M,Q = map(int,input().split())
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int,input().split())) for i in range(M)]
for l,r in lr:
num[l-1][r-1] += 1
for j in range(N):
for i in range(N-1,0,-1):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
pq = [list(map(int,input().split())) for i in range(Q)]
ans = []
for p,q in pq:
ans.append(num[p-1][q-1])
print(*ans,sep='\n')
| import sys
def input(): return sys.stdin.readline().strip()
N,M,Q = map(int,input().split())
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int,input().split())) for i in range(M)]
for l,r in lr:
num[l-1][r-1] += 1
for j in range(N):
for i in range(N-1,0,-1):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
pq = [list(map(int,input().split())) for i in range(Q)]
ans = []
for p,q in pq:
ans.append(num[p-1][q-1])
print(*ans,sep='\n')
| p03283 |
N,M,Q = list(map(int,input().split()))
A = [[0 for i in range(N+1)] for j in range(N+1)]
Acum = [[0 for i in range(N+1)] for j in range(N+1)]
for _ in range(M):
L,R = list(map(int,input().split()))
A[L-1][R-1] += 1
#2次元累積和
for i in range(N):
for j in range(N):
Acum[i+1][j+1] = Acum[i][j+1] + Acum[i+1][j] - Acum[i][j] + A[i][j]
# print(Acum)
for _ in range(Q):
p,q= list(map(int,input().split()))
A = Acum[q][q]-Acum[p-1][q]-Acum[q][p-1]+Acum[p-1][p-1]
print(A)
| """
22:40:00
"""
N, M, Q = list(map(int, input().split()))
fields = [[0] * (N+1) for i in range(N+1)]
accs = [[0] * (N+1) for i in range(N+1)]
for i in range(M):
L,R = list(map(int, input().split()))
fields[L][R] += 1
for i in range(1,N+1):
for j in range(1,N+1):
accs[i][j] = fields[i][j] + accs[i-1][j] + accs[i][j-1] - accs[i-1][j-1]
# print(accs)
ans = []
for i in range(Q):
p,q = list(map(int, input().split()))
ans.append(accs[q][q] - accs[p-1][q])
print((accs[q][q] - accs[p-1][q]))
# print(*ans) | p03283 |
n,m,q=list(map(int,input().split()))
line=[[0]*(n+1) for _ in range(n+1)]
for i in range(m):
l,r=list(map(int,input().split()))
for j in range(0,l):
for k in range(r-1,n):
line[j][k]+=1
for _ in range(q):
x,y=list(map(int,input().split()))
print((line[x-1][y-1])) | n,m,q=list(map(int,input().split()))
line=[[0]*(n+1) for _ in range(n+1)]
for i in range(m):
l,r=list(map(int,input().split()))
line[l][r]+=1
for i in range(n+1):
for j in range(n):
line[i][j+1]+=line[i][j]
for i in range(n+1):
for j in range(n):
line[j+1][i]+=line[j][i]
for i in range(q):
x,y=list(map(int,input().split()))
print((line[y][y]-line[x-1][y]-line[y][x-1]+line[x-1][x-1])) | p03283 |
n,m,q=list(map(int,input().split()))
d=[[0 for j in range(n)] for i in range(n)]
for i in range(m):
l,r=[int(x)-1 for x in input().split()]
d[l][r]+=1
for l in range(n):
for r in range(1,n):
d[l][r]+=d[l][r-1]
for l in range(n-1,0,-1):
for r in range(n):
d[l-1][r]+=d[l][r]
for i in range(q):
l,r=[int(x)-1 for x in input().split()]
print((d[l][r])) | n,m,q=list(map(int,input().split()))
d=[[0 for j in range(n)] for i in range(n)]
for i in range(m):
l,r=list(map(int,input().split()))
d[n-l][r-1]+=1
for l in range(n):
for r in range(1,n):
d[l][r]+=d[l][r-1]
for l in range(1,n):
for r in range(n):
d[l][r]+=d[l-1][r]
for i in range(q):
l,r=list(map(int,input().split()))
print((d[n-l][r-1])) | p03283 |
n,m,q = list(map(int, input().split()))
List1 = [[0 for i in range(n)] for j in range(n)]
List2 = [[0 for i in range(n)] for j in range(n)]
for i in range(m):
l,r = list(map(int, input().split()))
List1[l - 1][r - 1] += 1
for i in range(n):
for j in range(i, n):
for k in range(i, j + 1):
for l in range(k, j + 1):
List2[i][j] += List1[k][l]
for i in range(q):
a, b = list(map(int, input().split()))
print((List2[a - 1][b - 1])) | n,m,q = list(map(int, input().split()))
List1 = [[0 for i in range(n+1)] for j in range(n+1)]
List2 = [[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()))
List1[l - 1][r - 1] += 1
for i in range(n):
for j in range(n - i):
List2[j][j + i] = List2[j + 1][j + i] + List2[j][j + i - 1] - List2[j + 1][j + i - 1] + List1[j][j + i]
for i in range(q):
a, b = list(map(int, input().split()))
print((List2[a - 1][b - 1])) | p03283 |
n, m, q = [int(i) for i in input().split()]
m_list = [[0 for i in range(n+1)] for j in range(n+1)]
dynamic = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(m):
l, r = [int(i) for i in input().split()]
m_list[l][r] += 1
for i in range(1, n+1):
for j in range(i, n+1):
dynamic[i][j] = dynamic[i][j-1]
for k in range(i, j+1):
dynamic[i][j] += m_list[k][j]
for i in range(q):
l, r = [int(i) for i in input().split()]
print((dynamic[l][r]))
| n, m, q = [int(i) for i in input().split()]
imos = [[0 for r in range(n+1)] for l in range(n+1)]
for i in range(m):
l, r = [int(i) - 1 for i in input().split()]
imos[0][r] += 1
imos[l+1][r] -= 1
#imos法
for l in range(n):
for r in range(1, n):
imos[l][r] += imos[l][r-1]
for r in range(n):
for l in range(1, n):
imos[l][r] += imos[l-1][r]
for i in range(q):
l, r = [int(i) - 1 for i in input().split()]
print((imos[l][r])) | p03283 |
n, m, qn = list(map(int, input().split()))
t = [list(map(int, input().split())) for _ in range(m)]
qs = [list(map(int, input().split())) for _ in range(qn)]
r = dict()
for i in range(1, n + 1):
r[i] = set()
l = dict()
for i in range(1, n + 1):
l[i] = set()
for x in range(len(t)):
L, R = t[x]
for i in range(R, n + 1):
l[i].add(x)
for i in range(1, L + 1):
r[i].add(x)
for p, q in qs:
print((len(r[p] & l[q]))) | def arr(row, column, value): return [[value for _ in range(column)] for _ in range(row)]
n, m, q = list(map(int, input().split()))
sum_range = arr(n + 1, n + 1, 0)
#sum_range[0][0] - sum_range[n][n]まで
#初期値0
#行列値は1からnを取るが、累積和を加算する過程で行列を1引いたものを参照するので、[0][0]がエラーにならないと便利？
for _ in range(m):
L, R = list(map(int, input().split()))
sum_range[L][R] += 1#(L, R)間を運行す列車の数を代入
for L in range(1, n + 1):
for R in range(1, n + 1):
#累積和を取る（53:44あたり）
#https://www.youtube.com/watch?v=OdJH-io-sVw
sum_range[L][R] += sum_range[L - 1][R]
sum_range[L][R] += sum_range[L][R - 1]
sum_range[L][R] -= sum_range[L - 1][R - 1]
#print(sum_range)
for _ in range(q):
p, q = list(map(int, input().split()))
ans = sum_range[q][q] - sum_range[p - 1][q] - sum_range[q][p - 1] + sum_range[p - 1][p - 1]
print(ans) | p03283 |
def ary(r, c, val=False): return [[val for _ in range(c)] for _ in range(r)]
def nl(): return list(map(int, input().split()))
n, m, q = nl()
M = ary(n + 1, n + 1, 0)
for _ in range(m):
l, r = nl()
M[l][r] += 1
for L in range(1, n + 1):
for R in range(1, n + 1):
M[L][R] += M[L - 1][R]
M[L][R] += M[L][R - 1]
M[L][R] -= M[L - 1][R - 1]
for _ in range(q):
p, q = list(map(int, input().split()))
ans = M[q][q] - M[p - 1][q] - M[q][p - 1] + M[p - 1][p - 1]
print(ans) | N, M, Q = list(map(int, input().split()))
T = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
T[L][R] += 1
for L in range(1, N + 1):
for R in range(1, N + 1):
T[L][R] += T[L - 1][R]
T[L][R] += T[L][R - 1]
T[L][R] -= T[L - 1][R - 1]
for _ in range(Q):
P, Q = list(map(int, input().split()))
ans = 0
ans += T[Q][Q]
ans -= T[P - 1][Q]
ans -= T[Q][P - 1]
ans += T[P - 1][P - 1]
print(ans) | p03283 |
N, M, Q = list(map(int, input().split()))
x = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
x[L][R] += 1
c = [[0 for _ in range(N + 1)] for _ in range(N + 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 _ in range(Q):
P, Q = list(map(int, input().split()))
ans = 0
for i in range(P, Q + 1):
ans += c[i][Q] - c[i][P - 1]
print(ans)
| import sys
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
t = [[0] * (N + 1) for _ in range(N + 1)]
# es[L][R]:=区間[L,R]を走る列車の本数
for _ in range(M):
l, r = list(map(int, input().split()))
t[l][r] += 1
for L in range(1, N + 1):
for R in range(1, N + 1):
t[L][R] += t[L - 1][R]
t[L][R] += t[L][R - 1]
t[L][R] -= t[L - 1][R - 1]
# 累積和のテーブルを作る
# 最終的には
# t[L][R]には区間が[L,R]に含まれる本数を入れるが、
# 現時点では区間が[L,R]に一致する本数しか入っていない
# ここに区間が[L-1,R]に含まれる本数と
# 区間が[L,R-1]に含まれる本数を足すと
# 区間が[L,R]に含まれる範囲をカバーできるが、
# 区間が[L-1][R-1]の範囲が重複して足されている
for _ in range(Q):
p, q = list(map(int, input().split()))
print((t[q][q] - t[p - 1][q] - t[q][p - 1] + t[p - 1][p - 1]))
# 2次元累積和
| p03283 |
class Acc2D:
def __init__(self, src):
self.acc2d = self._build(src)
def _build(self, src):
h, w = len(src), len(src[0])
ret = [[0] * w for _ in range(h)]
for r in range(h):
for c in range(w):
ret[r][c] = src[r][c]
if r > 0:
ret[r][c] += ret[r - 1][c]
if c > 0:
ret[r][c] += ret[r][c - 1]
if r > 0 and c > 0:
ret[r][c] -= ret[r - 1][c - 1]
return ret
def get(self, r1, c1, r2, c2):
"""[(r1,c1),(r2,c2)]"""
acc2d = self.acc2d
ret = acc2d[r2][c2]
if r1 > 0:
ret -= acc2d[r1 - 1][c2]
if c1 > 0:
ret -= acc2d[r2][c1 - 1]
if r1 > 0 and c1 > 0:
ret += acc2d[r1 - 1][c1 - 1]
return ret
def main():
import sys
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
table = [[0] * (N + 1) for _ in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
table[L][R] += 1
acc2d = Acc2D(table)
for _ in range(Q):
p, q = list(map(int, input().split()))
res = acc2d.get(p, p, q, q)
print(res)
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.readline
N, M, Q = map(int, input().split())
tb = [[0] * (N + 1) for _ in range(N + 1)]
# tb[L][R]:=区間LR内を走る列車総数
for _ in range(M):
L, R = map(int, input().split())
tb[L][R] += 1
for L in range(1, N + 1):
for R in range(1, N + 1):
tb[L][R] += tb[L - 1][R]
tb[L][R] += tb[L][R - 1]
tb[L][R] -= tb[L - 1][R - 1]
ans = []
for _ in range(Q):
p, q = map(int, input().split())
ans.append(tb[q][q] - tb[p - 1][q] - tb[q][p - 1] + tb[p - 1][p - 1])
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| p03283 |
# coding: utf-8
n,m,q = list(map(int,input().split()))
M = [ list(map(int,input().split())) for i in range(m) ]
Q = [ list(map(int,input().split())) for i in range(q) ]
count = [0]*q
for i in range(q):
for j in range(m):
if Q[i][0] <= M[j][0] and M[j][1] <= Q[i][1]:
count[i] += 1
for i in range(q):
print((count[i])) | # coding: utf-8
n,m,q = list(map(int,input().split()))
M = [ list(map(int,input().split())) for i in range(m) ]
Q = [ list(map(int,input().split())) for i in range(q) ]
LR = [[0]*(n+1) for _ in range(n+1)]
for m in M:
LR[m[0]-1][m[1]] += 1
for l in range(n,-1,-1):
for r in range(0,n,1):
LR[l-1][r+1] = LR[l-1][r+1] + LR[l-1][r] + LR[l][r+1] - LR[l][r]
for q in Q:
print((LR[q[0]-1][q[1]])) | p03283 |
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc106/editorial.pdf
https://www.hamayanhamayan.com/entry/2018/08/18/234325
・累積和
"""
N, M, Q = list(map(int, input().split()))
lM, rM = [0] * M, [0] * M
pQ, qQ = [0] * Q, [0] * Q
LR = [[0] * N for i in range(N)]
# 都市番号を0-indexed
for i in range(M):
l, r = list(map(int, input().split()))
lM[i], rM[i] = l-1, r-1
LR[l-1][r-1] += 1
for i in range(Q):
p, q = list(map(int, input().split()))
pQ[i], qQ[i] = p-1, q-1
# 始点固定で終点を動かした累積和を出す
cnt = [[0] * N for i in range(N)]
for i in range(N):
cnt[i][i] = LR[i][i]
for j in range(1, N):
cnt[i][j] = cnt[i][j-1] + LR[i][j]
for i in range(Q):
ans = 0
for j in range(pQ[i], qQ[i]+1):
# ある終点についてもう和が出てるので、
# ここでは始点を動かして最終的な合計にする
ans += cnt[j][qQ[i]]
print(ans)
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc106/editorial.pdf
https://atcoder.jp/contests/abc106/submissions/3024983
https://imoz.jp/algorithms/imos_method.html
・二次元累積和
・最後にどこを足し引きするかは上記参考の二次元いもすと同じ話だと思う。
"""
N, M, Q = list(map(int, input().split()))
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
# 縦横両方について累積和を出す
# 先頭1行1列は0のままにしておく
for i in range(1, N+1):
for j in range(2, N+1):
LR[i][j] += LR[i][j-1]
for i in range(1, N+1):
for j in range(2, N+1):
LR[j][i] += LR[j-1][i]
for i in range(Q):
p, q = list(map(int, input().split()))
# +左上 -右上 -左下 +右下
ans = LR[p-1][p-1] - LR[p-1][q] - LR[q][p-1] + LR[q][q]
print(ans)
| p03283 |
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc106/editorial.pdf
https://atcoder.jp/contests/abc106/submissions/3024983
https://imoz.jp/algorithms/imos_method.html
・二次元累積和
・最後にどこを足し引きするかは上記参考の二次元いもすと同じ話だと思う。
"""
N, M, Q = list(map(int, input().split()))
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
# 縦横両方について累積和を出す
# 先頭1行1列は0のままにしておく
for i in range(1, N+1):
for j in range(2, N+1):
LR[i][j] += LR[i][j-1]
for i in range(1, N+1):
for j in range(2, N+1):
LR[j][i] += LR[j-1][i]
for i in range(Q):
p, q = list(map(int, input().split()))
# +左上 -右上 -左下 +右下
ans = LR[p-1][p-1] - LR[p-1][q] - LR[q][p-1] + LR[q][q]
print(ans)
| # -*- coding: utf-8 -*-
"""
参考：https://betrue12.hateblo.jp/entry/2018/08/18/224408
・二次元累積和
・こっちの方針のが分かりやすいかも。
"""
N, M, Q = list(map(int, input().split()))
LR = [[0] * (N) for i in range(N)]
for i in range(M):
l, r = list(map(int, input().split()))
# 左端=L、右端=Rの表
LR[l-1][r-1] += 1
# 二次元の縦横両方について累積和を出す
# 縦方向の足し方を逆からにすることで、今回の条件と合致できる
for i in range(N):
for j in range(1, N):
# 左端=L、右端<=Rになる
LR[i][j] += LR[i][j-1]
for i in range(N):
for j in range(N-2, -1, -1):
# 左端>=L、右端<=Rになる
LR[j][i] += LR[j+1][i]
for i in range(Q):
p, q = list(map(int, input().split()))
# ここでは添字指定だけで加減不要
ans = LR[p-1][q-1]
print(ans)
| p03283 |
n, m, q = list(map(int, input().split()))
ans = [[0] * (n+2) for _ in range(n+2)]
lr = [list(map(int, input().split())) for _ in range(m)]
for l, r in lr:
ans[0][r] += 1
ans[0][-1] -= 1
ans[l+1][-1] -= 1
ans[l+1][r] -= 1
for i in range(n+2):
for j in range(n+1):
ans[i][j+1] += ans[i][j]
for i in range(n+1):
for j in range(n+2):
ans[i+1][j] += ans[i][j]
for _ in range(q):
p, q = list(map(int, input().split()))
print((ans[p][q])) | n, m, q = list(map(int, input().split()))
ans = [[0] * (n+2) for _ in range(n+2)]
for _ in range(m):
l, r = list(map(int, input().split()))
ans[0][r] += 1
ans[0][-1] -= 1
ans[l+1][-1] -= 1
ans[l+1][r] -= 1
for i in range(n+2):
for j in range(n+1):
ans[i][j+1] += ans[i][j]
for i in range(n+1):
for j in range(n+2):
ans[i+1][j] += ans[i][j]
for _ in range(q):
p, q = list(map(int, input().split()))
print((ans[p][q])) | p03283 |
N, M, Q = list(map(int, input().split()))
# cum_sum[L][R]
cum_sum = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
cum_sum[L][R] += 1
for l in range(1, N+1):
for r in range(1, N+1):
cum_sum[l][r] += cum_sum[l][r-1]
for _ in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for l in range(p, q+1):
ans += cum_sum[l][q] - cum_sum[l][p-1]
print(ans)
| N, M, Q = list(map(int, input().split()))
# cum_sum[L][R]
cum_sum = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
cum_sum[L][R] += 1
for l in range(1, N+1):
for r in range(1, N+1):
cum_sum[l][r] += cum_sum[l][r-1] + cum_sum[l-1][r] - cum_sum[l-1][r-1]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((cum_sum[q][q]-cum_sum[q][p-1]-cum_sum[p-1][q]+cum_sum[p-1][p-1]))
| p03283 |
from collections import Counter
def bin(ll, target, key): # リストにtargetが最初に含まれる位置
if len(ll) < 100:
if target in [key(a) for a in ll]:
return [key(a) for a in ll].index(target)
return -1
length = len(ll)
l, r = ll[:length // 2], ll[length // 2:]
if key(r[0]) == target:
if key(l[-1]) != target:
return len(l)
return bin(l, target, key)
elif key(r[0]) > target:
return bin(l, target, key)
else:
return len(l) + bin(r, target, key)
def main():
n, m, q = [int(a) for a in input().split()]
QQQ = q
LRi = sorted([[int(a) for a in input().split()] for _ in range(m)], key=lambda it: it[0])
PQi = [([int(a) for a in input().split()], k) for k in range(q)]
# PQi = sorted(PQi, key=lambda a: a[0][1])
# PQi = sorted(PQi, key=lambda a: a[0][0])
TABLE = [] # iから始まる列車のRとその数
ii = 0
for i in range(1, n + 1):
a = [] # iから伸びる列車の右端
while True:
if ii >= len(LRi):
break
l, r = LRi[ii]
if l == i:
a.append(r)
ii += 1
else:
break
# a = sorted(a)
c = Counter(a)
TABLE.append([(a, c[a]) for a in sorted(c.keys())])
TABLE2 = [] # iから始まってjまでで終わる電車TABLE[i,j]
for i in range(1, 1 + n):
trains = TABLE[i - 1] # iから始まる電車
c = 0
res = [] # jまでで終わる電車の数
ccc = 0
for j in range(1, n + 1):
while True:
if c >= len(trains):
break
dst, num = trains[c]
if dst <= j:
ccc += num
c += 1
else:
break
res.append(ccc)
TABLE2.append(res)
for (p, q), k in PQi:
c = 0
for i in range(p, q + 1):
c += TABLE2[i - 1][q-1]
print(c)
# ii = 0
# res = {}
# while True:
# if ii >= len(PQi):
# break
#
# (l, r), k = PQi[ii]# pqに対して、その範囲内のカウンタ全部取得
# counts = []
# for i in range(l, r + 1):
# count = TABLE[i - 1] # タプル kまでの数v
# for rrrr, nnnnn in count:
# if rrrr <= r:
# counts.append((rrrr, nnnnn))
# else:
# break
# lls = [(r, k)] # 同じlから始まるQ
# ii += 1
# while True:
# if ii >= len(PQi):
# break
# (ll, rr), kk = PQi[ii]
# if ll == r:
# lls.append((rr, kk))
# ii += 1
# else:
# break
#
# lls = sorted(lls, key=lambda a: a[0])
# b = 0
# c = 0
# for r, k in lls:
# while True:
# if c >= len(counts):
# break
# kk, v = counts[c]
# if kk <= r:
# b += v
# c += 1
# else:
# break
# res[k] = b
# for i in range(QQQ):
# print(res[i])
if __name__ == '__main__':
main()
| from collections import Counter
def bin(ll, target, key): # リストにtargetが最初に含まれる位置
if len(ll) < 100:
if target in [key(a) for a in ll]:
return [key(a) for a in ll].index(target)
return -1
length = len(ll)
l, r = ll[:length // 2], ll[length // 2:]
if key(r[0]) == target:
if key(l[-1]) != target:
return len(l)
return bin(l, target, key)
elif key(r[0]) > target:
return bin(l, target, key)
else:
return len(l) + bin(r, target, key)
def main():
n, m, q = [int(a) for a in input().split()]
QQQ = q
LRi = sorted([[int(a) for a in input().split()] for _ in range(m)], key=lambda it: it[0])
PQi = [([int(a) for a in input().split()], k) for k in range(q)]
# PQi = sorted(PQi, key=lambda a: a[0][1])
# PQi = sorted(PQi, key=lambda a: a[0][0])
table1 = [ # l2rの電車の個数
[0] * n
for _ in range(n)
]
for l, r in LRi:
table1[l - 1][r - 1] += 1
table2 = [ # l2rの電車の個数のlに関しての累積和(iから始まってjより手前で終わる)
[0] * n
for _ in range(n)
]
for i in range(n):
c = 0
for j in range(i, n):
c += table1[i][j]
table2[i][j] = c
table3 = [ # 2次元累積和(iよりあとから始まってjより手前で終わる)
[0] * n
for _ in range(n)
]
for j in range(n):
c = 0
for i in reversed(list(range(0, j + 1))):
c += table2[i][j]
table3[i][j] = c
for (p, q), k in PQi:
print((table3[p - 1][q - 1]))
return
# TABLE = [] # iから始まる列車のRとその数
# ii = 0
# for i in range(1, n + 1):
# a = [] # iから伸びる列車の右端
# while True:
# if ii >= len(LRi):
# break
# l, r = LRi[ii]
# if l == i:
# a.append(r)
# ii += 1
# else:
# break
# # a = sorted(a)
# c = Counter(a)
#
# TABLE.append([(a, c[a]) for a in sorted(c.keys())])
#
# TABLE2 = [] # iから始まってjまでで終わる電車TABLE[i,j]
# for i in range(1, 1 + n):
# trains = TABLE[i - 1] # iから始まる電車
# c = 0
# res = [] # jまでで終わる電車の数
# ccc = 0
# for j in range(1, n + 1):
# while True:
# if c >= len(trains):
# break
# dst, num = trains[c]
# if dst <= j:
# ccc += num
# c += 1
# else:
# break
# res.append(ccc)
# TABLE2.append(res)
#
# for (p, q), k in PQi:
# c = 0
# for i in range(p, q + 1):
# c += TABLE2[i - 1][q - 1]
# print(c)
# ii = 0
# res = {}
# while True:
# if ii >= len(PQi):
# break
#
# (l, r), k = PQi[ii]# pqに対して、その範囲内のカウンタ全部取得
# counts = []
# for i in range(l, r + 1):
# count = TABLE[i - 1] # タプル kまでの数v
# for rrrr, nnnnn in count:
# if rrrr <= r:
# counts.append((rrrr, nnnnn))
# else:
# break
# lls = [(r, k)] # 同じlから始まるQ
# ii += 1
# while True:
# if ii >= len(PQi):
# break
# (ll, rr), kk = PQi[ii]
# if ll == r:
# lls.append((rr, kk))
# ii += 1
# else:
# break
#
# lls = sorted(lls, key=lambda a: a[0])
# b = 0
# c = 0
# for r, k in lls:
# while True:
# if c >= len(counts):
# break
# kk, v = counts[c]
# if kk <= r:
# b += v
# c += 1
# else:
# break
# res[k] = b
# for i in range(QQQ):
# print(res[i])
if __name__ == '__main__':
main()
| p03283 |
N, M, QN = [int(x) for x in input().split()]
MAT0 = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(M):
l, r = [int(x) for x in input().split()]
MAT0[l][r] += 1
MAT = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(0, N + 1):
MAT[i][j] = MAT[i][j - 1] + MAT0[i][j]
for i in range(QN):
p, q = [int(x) for x in input().split()]
ret = 0
for j in range(p, q + 1):
ret = ret + MAT[j][q] - MAT[j][p - 1]
print(ret)
| N, M, QN = [int(x) for x in input().split()]
MAT0 = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(M):
l, r = [int(x) for x in input().split()]
MAT0[l][r] += 1
MAT = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(1, N + 1):
MAT[i][j] = MAT[i][j - 1] + MAT0[i][j]
MM = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(1, N + 1):
MM[i][j] = MM[i - 1][j] + MAT[i][j]
for i in range(QN):
p, q = [int(x) for x in input().split()]
ret = 0
ret = ret + MM[q][q] - MM[q][p - 1] - MM[p - 1][q] + MM[p - 1][p - 1]
print(ret)
| p03283 |
n,m,q = list(map(int,input().split(" ")))
LR_2d = [[0 for i in range(n)] for i in range(n)]
for i in range(m):
L,R = list(map(int,input().split(" ")))
LR_2d[L-1][R-1] += 1
LR_2dsum = [[0 for i in range(n)] for i in range(n)]
for i in range(n):
LR_2dsum[i][0] = LR_2d[i][0]
for j in range(1,n):
LR_2dsum[i][j] = LR_2dsum[i][j-1] + LR_2d[i][j]
for i in range(q):
ans = 0
p_i,q_i = list(map(int,input().split(" ")))
for j in range(p_i-1,q_i):
if p_i == 1:
ans_j = LR_2dsum[j][q_i-1]
else:
ans_j = LR_2dsum[j][q_i-1] - LR_2dsum[j][p_i-2]
ans += ans_j
print(ans) | n,m,q = list(map(int,input().split(" ")))
LR_2d = [[0 for i in range(n+1)] for i in range(n+1)]
for i in range(m):
L,R = list(map(int,input().split(" ")))
LR_2d[L][R] += 1
LR_2dsum = [[0 for i in range(n+1)] for i in range(n+1)]
for j in range(1,n):
LR_2dsum[0][j] = LR_2dsum[0][j-1] + LR_2d[0][j]
for i in range(1,n+1):
for j in range(1,n+1):
LR_2dsum[i][j] = LR_2dsum[i-1][j] + LR_2dsum[i][j-1] - LR_2dsum[i-1][j-1] + LR_2d[i][j]
for i in range(q):
p_i,q_i = list(map(int,input().split(" ")))
ans = LR_2dsum[p_i-1][p_i-1] - LR_2dsum[p_i-1][q_i] - LR_2dsum[q_i][p_i-1] + LR_2dsum[q_i][q_i]
print(ans) | p03283 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import bisect
import array
def solve():
n, m, q = list(map(int, input().split()))
nl = [[] for j in range(n + 1)]
for e in (input().split() for _ in [0] * m):
l, r = int(e[0]), int(e[1])
bisect.insort_left(nl[l], r)
table = [array.array("i", [0] * (n + 1)) for j in range(n + 1)]
ran = array.array("i", list(range(n + 1)))
for i in ran:
table[i] = [bisect.bisect_right(nl[i], j) for j in ran]
a = [0] * q
s = array.array("i", a)
for i, e in enumerate(input().split() for _ in a):
l, r = int(e[0]), int(e[1])
s[i] = sum(table[j][r] - table[j][l - 1] for j in range(l, r + 1))
print(("\n".join(str(e) for e in s)))
if __name__ == "__main__":
solve()
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
import bisect
import array
def solve():
n, m, q = list(map(int, input().split()))
nl = [[0 for i in range(n + 1)] for j in range(n + 1)]
for e in [input().split() for _ in range(m)]:
l, r = int(e[0]), int(e[1])
nl[l][r] += 1
table = [array.array("i", [0] * (n + 2)) for j in range(n + 2)]
ran = array.array("i", list(range(n + 1)))
for i in ran:
for j in ran:
table[i][j + 1] = table[i][j] + nl[i][j]
for i, e in enumerate([input().split() for _ in range(q)]):
l, r = int(e[0]), int(e[1])
ans = 0
for j in range(l, r + 1):
ans += table[j][r + 1] - table[j][l]
print(ans)
if __name__ == "__main__":
solve()
| p03283 |
import sys
def main():
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
DP = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
l, r = list(map(int, input().split()))
for i in range(l+1):
for j in range(r, N+1):
DP[i][j] += 1
for _ in range(Q):
p, q = list(map(int, input().split()))
print((DP[p][q]))
if __name__ == '__main__':
main() | import sys
def main():
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
DP = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
l, r = list(map(int, input().split()))
DP[l][r] += 1
cum = [[0 for _ in range(N+1)] for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
cum[i][j] = DP[i][j] + cum[i-1][j] + cum[i][j-1] - cum[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]))
if __name__ == '__main__':
main() | p03283 |
import sys
def main():
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
DP = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
l, r = list(map(int, input().split()))
DP[l][r] += 1
cum = [[0 for _ in range(N+1)] for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
cum[i][j] = DP[i][j] + cum[i-1][j] + cum[i][j-1] - cum[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]))
if __name__ == '__main__':
main() | import sys
def main():
input = sys.stdin.readline
N, M, Q = list(map(int, input().split()))
Pos = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
l, r = list(map(int, input().split()))
Pos[l][r] += 1
cum = [[0 for _ in range(N+1)] for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
cum[i][j] = Pos[i][j] + cum[i-1][j] + cum[i][j-1] - cum[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]))
if __name__ == '__main__':
main() | p03283 |
# -*- coding: utf-8 -*-
line = input().split(" ")
N = int(line[0])
M = int(line[1])
Q = int(line[2])
memo = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
line = input().split(" ")
l = int(line[0])
r = int(line[1])
memo[l][r] += 1
for _ in range(Q):
line = input().split(" ")
p = int(line[0])
q = int(line[1])
ret = 0
for i in range(p,q+1):
for j in range(i,q+1):
ret += memo[i][j]
print(ret)
| # -*- coding: utf-8 -*-
n,m,q = list(map(int, input().split()))
d = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l,r = list(map(int, input().split()))
d[l][r] += 1
for i in range(n,0,-1):
for j in range(n):
d[i][j+1] += d[i][j]
for j in range(n,0,-1):
for i in range(n,0,-1):
d[i-1][j] += d[i][j]
pq = []
for _ in range(q):
p,q = list(map(int, input().split()))
pq.append([p,q])
# print(d)
for o in pq:
print((d[o[0]][o[1]]))
| p03283 |
n,m,q= list(map(int,input().split()))
lrList=[list(map(int,input().split()))for i in range(m)]
pqList=[list(map(int,input().split()))for i in range(q)]
for pq in pqList:
ans = 0
for lr in lrList:
ans +=(pq[0] <= lr[0] and pq[1] >= lr[1])
print(ans) | n,m,q= list(map(int,input().split()))
dataList = [[0 for xIndex in range(n+1)]for yIndex in range(n+1)]
for i in range(m):
xTemp,yTemp = list(map(int,input().split()))
dataList[yTemp][xTemp]+=1
pqList=[list([int(x) for x in input().split()])for i in range(q)]
for yIndex in range(1,n+1):
for xIndex in range(1,n+1):
dataList[yIndex][xIndex]+=dataList[yIndex][xIndex-1]
for yIndex in range(1,n+1):
for xIndex in range(1,n+1):
dataList[yIndex][xIndex]+=dataList[yIndex-1][xIndex]
for pq in pqList:
p = pq[0]-1
q = pq[1]
print((dataList[q][q]+dataList[p][p]-dataList[p][q]-dataList[q][p])) | p03283 |
from itertools import accumulate
import sys
sdin = sys.stdin.readline
n,m,q = list(map(int, sdin().split()))
lr = []
for i in range(m):
l,r = list(map(int, sdin().split()))
lr.append(tuple([l-1, r-1]))
pq = []
for _ in range(q):
p,q = list(map(int, sdin().split()))
pq.append(tuple([p-1, q-1]))
# n×nフィールドを用意して各列車のl,r点をプロット
field = [[0 for _ in range(n)] for _ in range(n)]
for l, r in lr:
field[l][r] += 1
# fieldのx方向の累積和を取る
field_cum = [list(accumulate(field[i])) for i in range(n)]
# 各クエリに対し、rがpからqの間に入っているものを足し合わせる
for p,q in pq:
ans = 0
for i in range(p,q+1):
ans += field_cum[i][q]
print(ans) | from itertools import accumulate
import sys
sdin = sys.stdin.readline
n,m,q = list(map(int, sdin().split()))
lr = []
for i in range(m):
l,r = list(map(int, sdin().split()))
lr.append(tuple([l-1, r-1]))
pq = []
for _ in range(q):
p,q = list(map(int, sdin().split()))
pq.append(tuple([p-1, q-1]))
# n×nフィールドを用意して各列車のl,r点をプロット
field = [[0 for _ in range(n)] for _ in range(n)]
for l, r in lr:
field[l][r] += 1
# fieldのx方向の累積和を取る
field_cum = [list(accumulate(field[i])) for i in range(n)]
# field_cumのy方向の累積和をとる
for r in range(1,n):
for l in range(n):
field_cum[r][l] += field_cum[r-1][l]
# 各クエリに対し、長方形内部にあるものの個数を求める
for p,q in pq:
if p > 0:
print((field_cum[q][q] - field_cum[p-1][q] - field_cum[q][p-1] + field_cum[p-1][p-1]))
else:
print((field_cum[q][q])) | p03283 |
from itertools import accumulate
import sys
sdin = sys.stdin.readline
n,m,q = list(map(int, sdin().split()))
lr = []
for i in range(m):
l,r = list(map(int, sdin().split()))
lr.append(tuple([l-1, r-1]))
pq = []
for _ in range(q):
p,q = list(map(int, sdin().split()))
pq.append(tuple([p-1, q-1]))
# n×nフィールドを用意して各列車のl,r点をプロット
field = [[0 for _ in range(n)] for _ in range(n)]
for l, r in lr:
field[l][r] += 1
# fieldのx方向の累積和を取る
field_cum = [list(accumulate(field[i])) for i in range(n)]
# field_cumのy方向の累積和をとる
for r in range(1,n):
for l in range(n):
field_cum[r][l] += field_cum[r-1][l]
# 各クエリに対し、長方形内部にあるものの個数を求める
for p,q in pq:
if p > 0:
print((field_cum[q][q] - field_cum[p-1][q] - field_cum[q][p-1] + field_cum[p-1][p-1]))
else:
print((field_cum[q][q])) | from itertools import accumulate
import sys
sdin = sys.stdin.readline
n,m,q = list(map(int, sdin().split()))
lr = []
for i in range(m):
l,r = list(map(int, sdin().split()))
lr.append(tuple([l, r]))
pq = []
for _ in range(q):
p,q = list(map(int, sdin().split()))
pq.append(tuple([p, q]))
# n×nフィールドを用意して各列車のl,r点をプロット
field = [[0 for _ in range(n+1)] for _ in range(n+1)]
for l, r in lr:
field[l][r] += 1
# fieldのx方向の累積和を取る
field_cum = [list(accumulate(field[i])) for i in range(n+1)]
# field_cumのy方向の累積和をとる
for r in range(1,n+1):
for l in range(n+1):
field_cum[r][l] += field_cum[r-1][l]
# 各クエリに対し、長方形内部にあるものの個数を求める
for p,q in pq:
print((field_cum[q][q] - field_cum[p-1][q] - field_cum[q][p-1] + field_cum[p-1][p-1]))
| p03283 |
from itertools import accumulate
import sys
sdin = sys.stdin.readline
n,m,q = list(map(int, sdin().split()))
lr = []
for i in range(m):
l,r = list(map(int, sdin().split()))
lr.append(tuple([l, r]))
pq = []
for _ in range(q):
p,q = list(map(int, sdin().split()))
pq.append(tuple([p, q]))
# n×nフィールドを用意して各列車のl,r点をプロット
field = [[0 for _ in range(n+1)] for _ in range(n+1)]
for l, r in lr:
field[l][r] += 1
# fieldのx方向の累積和を取る
field_cum = [list(accumulate(field[i])) for i in range(n+1)]
# field_cumのy方向の累積和をとる
for r in range(1,n+1):
for l in range(n+1):
field_cum[r][l] += field_cum[r-1][l]
# 各クエリに対し、長方形内部にあるものの個数を求める
for p,q in pq:
print((field_cum[q][q] - field_cum[p-1][q] - field_cum[q][p-1] + field_cum[p-1][p-1]))
| import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
from itertools import accumulate
n,m,q = li()
grid = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l,r = li()
grid[l][r] += 1
grid_cum = [list(accumulate(grid[row])) for row in range(n+1)]
for row in range(n):
for col in range(n+1):
grid_cum[row+1][col] += grid_cum[row][col]
for _ in range(q):
p,q = li()
print((grid_cum[q][q] - grid_cum[p-1][q] - grid_cum[q][p-1] + grid_cum[p-1][p-1]))
| p03283 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,m,q = li()
train = []
query = []
field = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
train.append(tuple(li()))
for _ in range(q):
query.append(tuple(li()))
for ts, tt in train:
field[ts][tt] += 1
for r in range(n+1):
for c in range(n):
field[r][c+1] += field[r][c]
for c in range(n+1):
for r in range(n):
field[r+1][c] += field[r][c]
for qs,qt in query:
print((field[qt][qt] - field[qt][qs-1] - field[qs-1][qt] + field[qs-1][qs-1]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def cum_2d(field:list):
row = len(field)
col = len(field[0])
# 横方向に累積和
for r in range(row):
for c in range(col-1):
field[r][c+1] += field[r][c]
# 縦方向に累積和
for c in range(col):
for r in range(row-1):
field[r+1][c] += field[r][c]
return field
n,m,q = li()
train = []
query = []
field = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
train.append(tuple(li()))
for _ in range(q):
query.append(tuple(li()))
for ts, tt in train:
field[ts][tt] += 1
field = cum_2d(field)
for qs,qt in query:
print((field[qt][qt] - field[qt][qs-1] - field[qs-1][qt] + field[qs-1][qs-1]))
| p03283 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def cum_2d(field:list):
row = len(field)
col = len(field[0])
# 横方向に累積和
for r in range(row):
for c in range(col-1):
field[r][c+1] += field[r][c]
# 縦方向に累積和
for c in range(col):
for r in range(row-1):
field[r+1][c] += field[r][c]
return field
n,m,q = li()
train = []
query = []
field = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
train.append(tuple(li()))
for _ in range(q):
query.append(tuple(li()))
for ts, tt in train:
field[ts][tt] += 1
field = cum_2d(field)
for qs,qt in query:
print((field[qt][qt] - field[qt][qs-1] - field[qs-1][qt] + field[qs-1][qs-1]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def cum_2d(field:list):
row = len(field)
col = len(field[0])
# 横方向に累積和
for r in range(row):
for c in range(col-1):
field[r][c+1] += field[r][c]
# 縦方向に累積和
for c in range(col):
for r in range(row-1):
field[r+1][c] += field[r][c]
return field
n,m,q = li()
grid = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l,r = li()
grid[l][r] += 1
grid = cum_2d(grid)
for _ in range(q):
p,q = li()
print((grid[q][q] + grid[p-1][p-1] - grid[q][p-1] - grid[p-1][q]))
| p03283 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def cum_2d(field:list):
row = len(field)
col = len(field[0])
# 横方向に累積和
for r in range(row):
for c in range(col-1):
field[r][c+1] += field[r][c]
# 縦方向に累積和
for c in range(col):
for r in range(row-1):
field[r+1][c] += field[r][c]
return field
n,m,q = li()
grid = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l,r = li()
grid[l][r] += 1
grid = cum_2d(grid)
for _ in range(q):
p,q = li()
print((grid[q][q] - grid[q][p-1] - grid[p-1][q] + grid[p-1][p-1]))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def cum_2d(field: list):
row = len(field)
col = len(field[0])
# 横方向に累積和
for r in range(row):
for c in range(col - 1):
field[r][c + 1] += field[r][c]
# 縦方向に累積和
for c in range(col):
for r in range(row - 1):
field[r + 1][c] += field[r][c]
return field
n,m,q = li()
field = [[0]*(n+1) for _ in range(n+1)]
for _ in range(m):
l, r = li()
field[l][r] += 1
field = cum_2d(field)
for _ in range(q):
pi, qi = li()
print((field[qi][qi] - field[qi][pi-1] - field[pi-1][qi] + field[pi-1][pi-1])) | p03283 |
def LI(): return list(map(int, input().split()))
def LI_(): return list([int(x) - 1 for x in input().split()])
if __name__ == "__main__":
N, M, Q = LI()
LR = [[0]*(N+1) for _ in range(N+1)]
for i in range(M):
l, r = LI()
LR[l][r] += 1
# 二次元累積和
for i in range(1, N+1):
for j in range(1, N+1):
LR[i][j] += LR[i][j-1]
LR[i][j] += LR[i-1][j]
LR[i][j] -= LR[i-1][j-1]
for _ in range(Q):
p, q = LI()
p -= 1
result = LR[q][q] - LR[p][q] - LR[q][p] + LR[p][p]
print(result)
| from itertools import accumulate as acc
def LI(): return list(map(int, input().split()))
def LI_(): return list([int(x) - 1 for x in input().split()])
if __name__ == "__main__":
N, M, Q = LI()
LR = [[0]*N for _ in range(N)]
for i in range(M):
l, r = LI_()
LR[l][r] += 1
# 二次元累積和
S = [[0] * N for _ in range(N)]
for i, row in enumerate(LR):
LR[i] = list(acc(row))
for i, col in enumerate(zip(*LR)):
S[i] = list(acc(reversed(col)))
for _ in range(Q):
p, q = LI()
# 必ず正方形だから、
print((S[q-1][N-p]))
| p03283 |
from itertools import accumulate as acc
import sys
if __name__ == "__main__":
s = sys.stdin.readlines()
N, M, Q = list(map(int, s[0].split()))
LR = [[0]*N for _ in range(N)]
for l, r in (list(map(int, e.split())) for e in s[1:M + 1]):
LR[l - 1][r - 1] += 1
S = [tuple(acc(reversed(s))) for s in zip(*(acc(x) for x in LR))]
print(('\n'.join(map(str, (S[q - 1][N - p] for p, q in (list(map(int, e.split())) for e in s[M + 1:])))))) | from itertools import accumulate as acc
import sys
if __name__ == "__main__":
s = sys.stdin.readlines()
N, M, Q = list(map(int, s[0].split()))
LR = [[0]*N for _ in [0]*N]
for l, r in (list(map(int, e.split())) for e in s[1:M + 1]):
LR[l - 1][r - 1] += 1
S = [tuple(acc(reversed(s))) for s in zip(*(acc(x) for x in LR))]
print(('\n'.join(map(str, (S[q - 1][N - p] for p, q in (list(map(int, e.split())) for e in s[M + 1:]))))))
| p03283 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,q = LI()
lr = [LI_() for _ in range(m)]
pq = [LI_() for _ in range(q)]
ls = [set() for _ in range(n)]
rs = [set() for _ in range(n)]
for i in range(m):
l,r = lr[i]
ls[l].add(i)
rs[r].add(i)
for i in range(n-2,-1,-1):
ls[i] |= ls[i+1]
for i in range(1,n):
rs[i] |= rs[i-1]
rr = []
for p,q in pq:
rr.append(len(ls[p] & rs[q]))
return '\n'.join(map(str, rr))
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
class Ruiwa():
def __init__(self, a):
self.H = h = len(a)
self.W = w = len(a[0])
self.R = r = a
for i in range(h):
for j in range(1,w):
r[i][j] += r[i][j-1]
for i in range(1,h):
for j in range(w):
r[i][j] += r[i-1][j]
def search(self, x1, y1, x2, y2):
if x1 > x2 or y1 > y2:
return 0
r = self.R
rr = r[y2][x2]
if x1 > 0 and y1 > 0:
return rr - r[y1-1][x2] - r[y2][x1-1] + r[y1-1][x1-1]
if x1 > 0:
rr -= r[y2][x1-1]
if y1 > 0:
rr -= r[y1-1][x2]
return rr
def main():
n,m,q = LI()
lr = [LI_() for _ in range(m)]
pq = [LI_() for _ in range(q)]
a = [[0]*n for _ in range(n)]
for l,r in lr:
a[l][r] += 1
rui = Ruiwa(a)
rr = []
for p,q in pq:
rr.append(rui.search(p,p,q,q))
return '\n'.join(map(str, rr))
print(main())
| p03283 |
N,M,Q = list(map(int,input().split()))
C = {i:{} for i in range(1,N+1)}
for _ in range(M):
L,R = list(map(int,input().split()))
if L not in C[R]:
C[R][L] = 0
C[R][L] += 1
for _ in range(Q):
p,q = list(map(int,input().split()))
A = {i:0 for i in range(1,N+1)}
for i in range(1,q+1):
for a in C[i]:
A[a] += C[i][a]
cnt = 0
for a in range(p,N+1):
cnt += A[a]
print(cnt) | N,M,Q = list(map(int,input().split()))
A = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L,R = list(map(int,input().split()))
A[L][R] += 1
B = [[0 for _ in range(N+2)] for _ in range(N+2)]
for i in range(N,0,-1):
for j in range(1,N+1):
B[i][j] = A[i][j]+B[i+1][j]+B[i][j-1]-B[i+1][j-1]
for _ in range(Q):
p,q = list(map(int,input().split()))
print((B[p][q])) | p03283 |
N,M,Q = list(map(int,input().split()))
A = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
l,r = list(map(int,input().split()))
A[l][r] += 1
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
dp[N][1] = A[N][1]
for j in range(2,N+1):
dp[N][j] = dp[N][j-1]+A[N][j]
for i in range(N-1,0,-1):
dp[i][1] = dp[i+1][1]+A[i][1]
for i in range(N-1,0,-1):
for j in range(2,N+1):
dp[i][j] = A[i][j]+dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1]
for _ in range(Q):
p,q = list(map(int,input().split()))
print((dp[p][q])) | N,M,Q = list(map(int,input().split()))
A = [[0 for _ in range(N+1)] for _ in range(N+1)]
for _ in range(M):
L,R = list(map(int,input().split()))
A[L][R] += 1
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
dp[N][N] = A[N][N]
for i in range(N-1,0,-1):
for j in range(i,N+1):
dp[i][j] = A[i][j]
if j>i:
dp[i][j] += dp[i+1][j]+dp[i][j-1]-dp[i+1][j-1]
for _ in range(Q):
p,q = list(map(int,input().split()))
print((dp[p][q])) | p03283 |
import sys
input = sys.stdin.readline
def main():
N,M,Q = list(map(int,input().split()))
go = [[0 for _ in range(N)] for i in range(N)]
for _ in range(M):
L,R = list(map(int,input().split()))
go[L-1][R-1] += 1
qu = []
for _ in range(Q):
p,q = list(map(int,input().split()))
qu.append((p-1,q-1))
num = [[0 for _ in range(N)] for _ in range(N)]
for i in range(N):
num[i][0] = go[i][0]
for i in range(N):
for j in range(N-1):
num[i][j+1] = num[i][j] + go[i][j+1]
for i in range(Q):
ans = 0
p,q = qu[i]
for j in range(p,q+1):
ans += num[j][q]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N,M,Q = list(map(int,input().split()))
go = [[0 for _ in range(N)] for i in range(N)]
for _ in range(M):
L,R = list(map(int,input().split()))
go[L-1][R-1] += 1
qu = []
for _ in range(Q):
p,q = list(map(int,input().split()))
qu.append((p,q))
num = [[0 for _ in range(N)] for _ in range(N)]
_num = [[0 for _ in range(N)] for _ in range(N+1)]
for i in range(N):
num[i][0] = go[i][0]
for i in range(N):
for j in range(N-1):
num[i][j+1] = num[i][j] + go[i][j+1]
for i in range(N):
for j in range(N):
_num[j+1][i] = _num[j][i] + num[j][i]
for i in range(Q):
p,q = qu[i]
ans = _num[q][q-1] - _num[p-1][q-1]
print(ans)
if __name__ == "__main__":
main()
| p03283 |
N,M,Q = [ int(it) for it in input().split()]
grid = [ [0]*N for i in range(N) ]
gridsml = [ [0]*N for i in range(N) ]
for i in range(M):
s,g = [ int(it)-1 for it in input().split()]
grid[s][g]+=1
for i in range(N):
gridsml[i][0]=grid[i][0]
for j in range(1,N):
gridsml[i][j]+=gridsml[i][j-1]+grid[i][j]
for i in range(Q):
s,g = [ int(it)-1 for it in input().split()]
m = 0
for i in range(s,N):
m += gridsml[i][g]
print (m) | N,M,Q = [ int(it) for it in input().split() ]
lit = [ [ int(it)-1 for it in input().split() ] for i in range(M) ]
liq = [ [ int(it)-1 for it in input().split() ] for i in range(Q) ]
li = [[0]*(N+1) for i in range(N+1)]
for p,q in lit:
li[p+1][q+1]+=1
for i in range(N+1):
for j in range(N):
li[i][j+1] += li[i][j]
for p,q in liq:
s = 0
for i in range(p+1,N+1):
s += li[i][q+1]
print (s)
| p03283 |
from bisect import bisect_left
def main():
n, m, q = list(map(int, input().split()))
trains = [list(map(int, input().split())) for _ in range(m)]
queries = [list(map(int, input().split())) for _ in range(q)]
xmt = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
cmt = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
for train in trains:
xmt[train[0]][train[1]] += 1
for i in range(1, n + 1):
for j in range(1, n + 1):
cmt[i][j] = cmt[i][j - 1] + xmt[i][j]
#for i in range(n + 1):
# print(cmt[i])
for query in queries:
ans = 0
for j in range(query[0], query[1] + 1):
ans += cmt[j][query[1]] - cmt[j][query[0] - 1]
print(ans)
if __name__ == '__main__':
main() | from bisect import bisect_left
def main():
n, m, q = list(map(int, input().split()))
trains = [list(map(int, input().split())) for _ in range(m)]
queries = [list(map(int, input().split())) for _ in range(q)]
xmt = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
cmt = [[0 for _ in range(n + 1)] for _ in range(n + 1)]
for train in trains:
xmt[train[0]][train[1]] += 1
for i in range(1, n + 1):
for j in range(1, n + 1):
cmt[i][j] = cmt[i][j - 1] + (cmt[i - 1][j] - cmt[i - 1][j - 1]) + xmt[i][j]
for query in queries:
i, j = query
ans = cmt[j][j] - cmt[i - 1][j] - cmt[j][i - 1] + cmt[i - 1][i - 1]
print(ans)
if __name__ == '__main__':
main() | p03283 |
from collections import Counter
N,M,Q = list(map(int,input().split()))
T = [[0 for _ in range(N)] for _ in range(N)]
LR = []
for i in range(M):
L,R = list(map(int, input().split()))
LR.append(L*1000+R)
LRD = Counter(LR)
for key in LRD:
L,R=key//1000,key%1000
v = LRD[key]
for r in range(R-1,N):
for l in range(L):
T[l][r] += v
ans = []
for i in range(Q):
p,q = list(map(int, input().split()))
ans.append(T[p-1][q-1])
print(('\n'.join(map(str,ans))))
| N,M,Q = list(map(int,input().split()))
T = [[0 for _ in range(N+1)] for _ in range(N+1)]
for i in range(M):
L,R = list(map(int, input().split()))
T[L][R] += 1
for l in range(1,N+1):
for r in range(1,N+1):
T[l][r] += T[l-1][r]+T[l][r-1]-T[l-1][r-1]
ans = []
for i in range(Q):
p,q = list(map(int, input().split()))
ans.append(T[p-1][p-1]+T[q][q]-T[p-1][q]-T[q][p-1])
print(('\n'.join(map(str,ans))))
| p03283 |
N, M, Q = list(map(int, input().split()))
coordinate = [[0 for _ in range(N+1)] for i in range(N+1)]
for m in range(M):
l, r = list(map(int, input().split()))
coordinate[l-1][r-1] += 1
for i in range(N):
for j in range(1, N):
coordinate[i][j] += coordinate[i][j-1]
for i in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for i in range(p-1, q):
ans += coordinate[i][q-1] - coordinate[i][p-2]
print(ans) | N, M, Q = list(map(int, input().split()))
coordinate = [[0] * N for _ in range(N)]
for _ in range(M):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
coordinate[l][r] += 1
acc = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(N):
acc[i + 1][j + 1] = acc[i][j + 1] + acc[i + 1][j] - acc[i][j] + coordinate[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
p, q = p - 1, q - 1
ans = acc[N][q + 1] - acc[p][q + 1]
print(ans) | p03283 |
N, M, Q = list(map(int, input().split()))
coordinate = [[0] * N for _ in range(N)]
for _ in range(M):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
coordinate[l][r] += 1
acc = [[0] * (N + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(N):
acc[i + 1][j + 1] = acc[i][j + 1] + acc[i + 1][j] - acc[i][j] + coordinate[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
p, q = p - 1, q - 1
ans = acc[N][q + 1] - acc[p][q + 1]
print(ans) | 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)]
acc = [[0 for i in range(N+1)] for i in range(N+1)] # acc[i][j] = i以下からスタートしてj以下で終了する電車の数
coordinate = [[0 for i in range(N)] for i in range(N)]
for l, r in LR:
l -= 1
r -= 1
coordinate[l][r] += 1
for i in range(N):
for j in range(N):
acc[i+1][j+1] = acc[i][j+1] + acc[i+1][j] - acc[i][j] + coordinate[i][j]
for p, q in PQ:
p -= 1
ans = acc[N][q] - acc[p][q]
print(ans) | p03283 |
from bisect import bisect
N, M, Q = list(map(int, input().split()))
G = [[] for _ in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
G[L].append(R)
for i in range(N+1):
G[i].sort()
for _ in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for i in range(p, q+1):
ans += bisect(G[i], q)
print(ans) | N, M, Q = list(map(int, input().split()))
G = [[0]*(N+1) for _ in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
G[L][R] += 1
for i in range(N+1):
for j in range(1, N+1):
G[i][j] += G[i][j-1]
for _ in range(Q):
p, q = list(map(int, input().split()))
ans = 0
for i in range(p, q+1):
ans += G[i][q]
print(ans) | p03283 |
N, M, Q = list(map(int, input().split()))
city = [[0] * (N+1) for i in range(N+1)]
for i in range(M):
l, r = list(map(int, input().split()))
city[l][r] += 1
for i in range(N+1):
for j in range(N):
city[i][j+1] += city[i][j]
for i in range(Q):
p, q = list(map(int, input().split()))
print((sum([city[j][q] - city[j][p-1] for j in range(p, q+1)]))) | N, M, Q = list(map(int, input().split()))
city = [[0] * (N+1) for i in range(N+1)]
for i in range(M):
l, r = list(map(int, input().split()))
city[l][r] += 1
for i in range(N+1):
for j in range(N):
city[i][j+1] += city[i][j]
for i in range(N+1):
for j in range(N):
city[j+1][i] += city[j][i]
for i in range(Q):
p, q = list(map(int, input().split()))
print((city[q][q] - city[p-1][q] - city[q][p-1] + city[p-1][p-1])) | p03283 |
from operator import itemgetter
N, M, Q = list(map(int, input().split()))
LR = sorted([list(map(int, input().split())) for i in range(M)], key=itemgetter(0))
route = [[0 for i in range(N+1)] for i in range(N+1)]
for l in range(1, N+1):
flag = [1 for i in range(len(LR))]
for r in range(1, N+1):
count = 0
for idx, lr in enumerate(LR):
if flag[idx] and l <= lr[0] and lr[1] <= r:
count += 1
flag[idx] = 0
route[l][r] = route[l][r-1] + count
while len(LR):
if LR[0][0] == l:
LR.pop(0)
else:
break
for i in range(Q):
p, q = list(map(int, input().split()))
print((route[p][q]))
| import itertools
N, M, Q = list(map(int, input().split()))
route = [[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()))
route[L][R] += 1
for i in range(1, N):
route[i] = list(itertools.accumulate(route[i]))
for i in range(2, N+1):
for j in range(1, N+1):
route[i][j] += route[i-1][j]
for i in range(Q):
p, q = list(map(int, input().split()))
print((route[q][q]-route[p-1][q]-route[q][p-1]+route[p-1][p-1]))
| p03283 |
I=lambda:list(map(int,input().split()))
n,m,q=I()
k=n+2
l=[0]*k**2
for _ in range(m):
s,g=I()
l[s*k+g]+=1
for i in range(1,n+1):
for j in range(1,n+1):
l[i*k+j]+=l[i*k+j-1]
for i in range(1,n+1):
for j in range(1,n+1):
l[i*k+j]+=l[(i-1)*k+j]
for _ in range(q):
s,g=I()
print((l[g*k+g]-l[(s-1)*k+g]-l[g*k+s-1]+l[(s-1)*k+s-1])) | I=lambda:list(map(int,input().split()))
n,m,q=I()
l=[[0]*-~n for _ in range(n+1)]
for _ in range(m):
s,g=I()
l[s][g]+=1
for i in range(1,n+1):
for j in range(1,n+1):
l[i][j]+=l[i][j-1]
for j in range(1,n+1):
l[i][j]+=l[i-1][j]
for _ in range(q):
s,g=I()
print((l[g][g]-l[s-1][g]-l[g][s-1]+l[s-1][s-1])) | p03283 |
n,m,q=list(map(int,input().split()))
a=[[0 for _ in range(n+1)]for _ in range(n+1)]
for _ in range(m):
l,r=list(map(int,input().split()))
a[l][r]+=1
for i in range(n+1):
for j in range(n):
a[i][j+1]+=a[i][j]
for i in range(n):
for j in range(n+1):
a[i+1][j]+=a[i][j]
for _ in range(q):
l,r=list(map(int,input().split()))
print((a[r][r]-a[r][l-1]-a[l-1][r]+a[l-1][l-1])) | n,m,q=list(map(int,input().split()))
a=[[0]*(n+1) for _ in range(n+1)]
for _ in range(m):
l,r=list(map(int,input().split()))
a[l][r]+=1
for i in range(n+1):
for j in range(n):
a[i][j+1]+=a[i][j]
for i in range(n):
for j in range(n+1):
a[i+1][j]+=a[i][j]
for _ in range(q):
q,p=list(map(int,input().split()))
print((a[p][p]-a[p][q-1]-a[q-1][p]+a[q-1][q-1])) | p03283 |
n, m, q = list(map(int, input().split()))
arr = [[0 for j in range(n)] for i in range(n)]
arr_sum = [[0 for j in range(n)] for i in range(n)]
arr_sum2 = [[0 for j in range(n)] for i in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
arr[l-1][r-1] += 1
for i in range(n):
for j in range(n):
if i <= j:
arr_sum[i][j] = sum(arr[i][:j+1])
for i in range(n):
for j in range(n):
if i <= j:
for k in range(i,j+1):
arr_sum2[i][j] += arr_sum[k][j]
ans_arr = []
for k in range(q):
p, q = list(map(int, input().split()))
ans = arr_sum2[p-1][q-1]
ans_arr.append(ans)
for i in ans_arr:
print(i) | n, m, q = list(map(int, input().split()))
arr = [[0 for j in range(n)] for i in range(n)]
arr_sum = []
arr_sum2 = []
for i in range(m):
l, r = list(map(int, input().split()))
arr[l-1][r-1] += 1
for i in range(n):
s = 0
arr_tmp = []
for j in range(n):
s += arr[i][j]
arr_tmp.append(s)
arr_sum.append(arr_tmp)
for j in range(n):
s = 0
arr_tmp2 = []
for i in range(n-1,-1,-1):
s += arr_sum[i][j]
arr_tmp2.append(s)
arr_sum2.append(arr_tmp2)
arr_sum3 = [[0 for j in range(n)] for i in range(n)]
for i in range(n):
for j in range(n):
arr_sum3[i][j] = arr_sum2[j][n-i-1]
ans_arr = []
for k in range(q):
p, q = list(map(int, input().split()))
ans = arr_sum3[p-1][q-1]
ans_arr.append(ans)
for i in ans_arr:
print(i) | p03283 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
from itertools import accumulate #list(accumulate(A))
def segfunc(a,b):
return a+b
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
n, M, Q = mi()
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
L = [0]*n
init(L)
lrpq = dp2(0, 3, M+Q)
for i in range(M):
l, r = mi()
lrpq[i][1] = l-1
lrpq[i][2] = r-1
for i in range(M, M+Q):
p, q = mi()
lrpq[i][0] = i
lrpq[i][1] = p-1
lrpq[i][2] = q-1
lrpq = sorted(lrpq, key=lambda x:(x[2], x[0]))
ans = [0]*(Q)
for i in range(M+Q):
if lrpq[i][0] == 0:
L[lrpq[i][1]] += 1
update(lrpq[i][1], L[lrpq[i][1]])
else:
ans[lrpq[i][0]-M] = query(lrpq[i][1], lrpq[i][2]+1)
for num in ans:
print(num) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
from itertools import accumulate #list(accumulate(A))
def segfunc(a,b):
return a+b
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
n, M, Q = mi()
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
L = [0]*n
init(L)
lrpq = dp2(0, 3, M+Q)
for i in range(M):
l, r = mi()
lrpq[i][1] = l-1
lrpq[i][2] = r-1
for i in range(M, M+Q):
p, q = mi()
lrpq[i][0] = i
lrpq[i][1] = p-1
lrpq[i][2] = q-1
lrpq = sorted(lrpq, key=lambda x:(x[2], x[0]))
ans = [0]*(Q)
for i in range(M+Q):
if lrpq[i][0] == 0:
#L[lrpq[i][1]] += 1
update(lrpq[i][1], seg[lrpq[i][1]+num-1]+1)
else:
ans[lrpq[i][0]-M] = query(lrpq[i][1], lrpq[i][2]+1)
for num in ans:
print(num) | p03283 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
from itertools import accumulate #list(accumulate(A))
# セグ木
def segfunc(a,b):
return a+b
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
n, M, Q = mi()
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
L = [0]*n
init(L)
lrpq = dp2(0, 3, M+Q)
for i in range(M):
l, r = mi()
lrpq[i][1] = l-1
lrpq[i][2] = r-1
for i in range(M, M+Q):
p, q = mi()
lrpq[i][0] = i
lrpq[i][1] = p-1
lrpq[i][2] = q-1
lrpq = sorted(lrpq, key=lambda x:(x[2], x[0]))
ans = [0]*(Q)
for i in range(M+Q):
if lrpq[i][0] == 0:
#L[lrpq[i][1]] += 1
update(lrpq[i][1], seg[lrpq[i][1]+num-1]+1)
else:
ans[lrpq[i][0]-M] = query(lrpq[i][1], lrpq[i][2]+1)
for num in ans:
print(num) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
from itertools import accumulate #list(accumulate(A))
# BIT木
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
N, M, Q = mi()
bit = BIT(N)
lrpq = dp2(0, 3, M+Q)
for i in range(M):
l, r = mi()
lrpq[i][1] = l-1
lrpq[i][2] = r-1
for i in range(M, M+Q):
p, q = mi()
lrpq[i][0] = i
lrpq[i][1] = p-1
lrpq[i][2] = q-1
lrpq = sorted(lrpq, key=lambda x:(x[2], x[0]))
ans = [0]*(Q)
for i in range(M+Q):
if lrpq[i][0] == 0:
#L[lrpq[i][1]] += 1
bit.add(lrpq[i][1]+1, 1)
#BIT_update(lrpq[i][1]+1, 1)
else:
bit.sum(lrpq[i][2])
if lrpq[i][1] > 0:
ans[lrpq[i][0]-M] = bit.sum(lrpq[i][2]+1) - bit.sum(lrpq[i][1])
else:
ans[lrpq[i][0]-M] = bit.sum(lrpq[i][2]+1)
for num in ans:
print(num) | p03283 |
N,M,Q = list(map(int,input().split()))
s = [[0 for j in range(501)] for i in range(501)]
for _ in range(M):
L,R = list(map(int,input().split()))
s[L][R] += 1
# 二次元累積和
for i in range(1,501):
for j in range(1,501):
s[i][j] += s[i-1][j] + s[i][j-1] - s[i-1][j-1]
# クエリに対してO(1)で求める
for _ in range(Q):
p,q = list(map(int,input().split()))
print((s[q][q]-s[p-1][q]-s[q][p-1]+s[p-1][p-1]))
| N,M,Q = list(map(int,input().split()))
c_sum = [[0 for j in range(N+1)] for i in range(N+1)]
for _ in range(M):
L,R = list(map(int,input().split()))
c_sum[L][R] += 1
# 二次元累積和の計算
for i in range(N):
for j in range(N):
c_sum[i+1][j+1] += c_sum[i+1][j] + c_sum[i][j+1] - c_sum[i][j]
for _ in range(Q):
p,q = list(map(int,input().split()))
print((c_sum[q][q] - c_sum[p-1][q] - c_sum[q][p-1] + c_sum[p-1][p-1]))
| p03283 |
N,M,Q = map(int,input().split())
src = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(M)]
src.sort(reverse=True)
qs = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(Q)]
q_arr = [[] for i in range(N)]
for i,(l,r) in enumerate(qs):
q_arr[l].append((r,i))
bit = [0] * (N+2)
def bit_add(a,w):
x = a
while x <= N:
bit[x] += w
x += (x & -x)
def bit_sum(a):
x = a
ret = 0
while x > 0:
ret += bit[x]
x -= (x & -x)
return ret
ans = [None] * Q
last_l = N-1
for l,r in src:
while last_l > l:
for qr,qi in q_arr[last_l]:
ans[qi] = bit_sum(qr+1)
last_l -= 1
bit_add(r+1, 1)
while last_l >= 0:
for qr,qi in q_arr[last_l]:
ans[qi] = bit_sum(qr+1)
last_l -= 1
print(*ans, sep='\n')
| N,M,Q = map(int,input().split())
src = [tuple(map(int,input().split())) for i in range(M)]
qs = [tuple(map(int,input().split())) for i in range(Q)]
imos = [[0]*(N+1) for i in range(N+1)]
for l,r in src:
imos[l][r] += 1
for i in range(N+1):
for j in range(N):
imos[i][j+1] += imos[i][j]
for i in range(N):
for j in range(N+1):
imos[i+1][j] += imos[i][j]
ans = []
for p,q in qs:
ans.append(imos[q][q] - imos[q][p-1] - imos[p-1][q] + imos[p-1][p-1])
print(*ans, sep='\n')
| p03283 |
N,M,Q = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(M)]
qs = [tuple(map(int,input().split())) for i in range(Q)]
imos = [[0]*(N+1) for i in range(N+1)]
for l,r in src:
imos[l][r] += 1
for i in range(N+1):
for j in range(N):
imos[i][j+1] += imos[i][j]
for i in range(N):
for j in range(N+1):
imos[i+1][j] += imos[i][j]
for p,q in qs:
ans = imos[p-1][p-1] + imos[q][q] - imos[p-1][q] - imos[q][p-1]
print(ans) | import sys
input = sys.stdin.readline
N,M,Q = map(int,input().split())
LR = [tuple(map(int,input().split())) for i in range(M)]
PQ = [tuple(map(int,input().split())) for i in range(Q)]
imos = [[0]*(N+1) for _ in range(N+1)]
for l,r in LR:
imos[l][r] += 1
for i in range(N+1):
for j in range(N):
imos[i][j+1] += imos[i][j]
for j in range(N+1):
for i in range(N):
imos[i+1][j] += imos[i][j]
ans = []
for p,q in PQ:
p -= 1
a = imos[q][q] + imos[p][p] - imos[p][q] - imos[q][p]
ans.append(a)
print(*ans, sep='\n')
| p03283 |
def main():
N, M, Q = list(map(int, input().split()))
S = [[0] * (N+1) for _ in range(N+1)]
for i in range(M):
L, R = list(map(int, input().split()))
S[L][R] += 1
for i in range(1,N+1):
for j in range(1,N+1):
S[i][j] += S[i-1][j] + S[i][j-1] - S[i-1][j-1]
for i in range(Q):
p, q = list(map(int, input().split()))
ans = S[q][q] - S[q][p-1] - S[p-1][q] + S[p-1][p-1]
print(ans)
main() | import sys
def input():
return sys.stdin.readline()[:-1]
def main():
N, M, Q = list(map(int, input().split()))
S = [[0] * (N+1) for _ in range(N+1)]
for i in range(M):
L, R = list(map(int, input().split()))
S[L][R] += 1
for i in range(1,N+1):
for j in range(1,N+1):
S[i][j] += S[i-1][j] + S[i][j-1] - S[i-1][j-1]
for i in range(Q):
p, q = list(map(int, input().split()))
ans = S[q][q] - S[q][p-1] - S[p-1][q] + S[p-1][p-1]
print(ans)
main() | p03283 |
from operator import itemgetter
import bisect
n, m, Q = list(map(int, input().split()))
train = [list(map(int, input().split())) + [i] for i in range(m)]
train_L = []
train_R = []
L_n = []
R_n = []
for i in sorted(train, key=itemgetter(0)):
train_L.append(i[0])
L_n.append(i[2])
for i in sorted(train, key=itemgetter(1)):
train_R.append(i[1])
R_n.append(i[2])
for i in range(Q):
p, q = list(map(int, input().split()))
p_set = set(L_n[bisect.bisect_left(train_L, p):])
q_set = set(R_n[:bisect.bisect_right(train_R, q)])
print((len(p_set & q_set))) | def getSumRange(L, R):
ans = sum[R][R] - sum[R][L - 1] - sum[L - 1][R] + sum[L - 1][L - 1]
return ans
n, m, Q = list(map(int, input().split()))
L = [0] * m
R = [0] * m
for i in range(m):
L[i], R[i] = list(map(int, input().split()))
p = [0] * Q
q = [0] * Q
for i in range(Q):
p[i], q[i] = list(map(int, input().split()))
sum = [[0] * (n + 1) for i in range(n + 1)]
for i in range(m):
sum[L[i]][R[i]] += 1
for i in range(n + 1):
for j in range(n + 1):
sum[i][j] += sum[i - 1][j]
sum[i][j] += sum[i][j - 1]
sum[i][j] -= sum[i - 1][j - 1]
for i in range(Q):
ans = getSumRange(p[i], q[i])
print(ans) | p03283 |
from itertools import islice
def main():
city_count, express_count, query_count = list(map(int, input().split()))
city_list = [(set(), set()) for _ in range(city_count + 1)]
for express_index in range(1, express_count + 1):
l, r = list(map(int, input().split()))
for city in islice(city_list, 1, l + 1):
city[0].add(express_index)
for city in islice(city_list, r, None):
city[1].add(express_index)
for _ in range(query_count):
p, q = list(map(int, input().split()))
city_p = city_list[p][0]
city_q = city_list[q][1]
print((len(city_p & city_q)))
if __name__ == '__main__':
main()
| from itertools import islice
def main():
city_count, express_count, query_count = list(map(int, input().split()))
city_list = [[[], []] for _ in range(city_count + 1)]
for express_index in range(1, express_count + 1):
l, r = list(map(int, input().split()))
for city in islice(city_list, 1, l + 1):
city[0].append(express_index)
for city in islice(city_list, r, None):
city[1].append(express_index)
for city in city_list:
city[0] = frozenset(city[0])
city[1] = frozenset(city[1])
for _ in range(query_count):
p, q = list(map(int, input().split()))
city_p = city_list[p][0]
city_q = city_list[q][1]
print((len(city_p & city_q)))
if __name__ == '__main__':
main()
| p03283 |
import bisect
n, m, q = list(map(int, input().split()))
edges = []
for i in range(m):
L, R = list(map(int, input().split()))
edges.append((L, R, i))
L_sorted = sorted(edges)
L_sorted_bi = [L for L, R, i in L_sorted]
L_cum_set = [set()for _ in range(m+1)]
for i in reversed(list(range(m))):
L_cum_set[i] = L_cum_set[i+1] | {L_sorted[i][2]}
R_sorted = sorted(edges, key=lambda x: x[1])
R_sorted_bi = [R for L, R, i in R_sorted]
R_cum_set = [set()for _ in range(m+1)]
for i in range(m):
R_cum_set[i+1] = R_cum_set[i] | {R_sorted[i][2]}
for _ in range(q):
p, q = list(map(int, input().split()))
idx = bisect.bisect_left(L_sorted_bi, p)
s = L_cum_set[idx]
idx = bisect.bisect_left(R_sorted_bi, q+1)
t = R_cum_set[idx]
print((len(s & t)))
| n, m, q = list(map(int, input().split()))
edges = [[0]*n for _ in range(n)]
for _ in range(m):
L, R = [int(x)-1 for x in input().split()]
edges[L][R] += 1
for _ in range(q):
p, q = list(map(int, input().split()))
lines = edges[p-1:q]
print((sum(sum(row[p-1:q]) for row in lines))) | p03283 |
n, m, q = list(map(int, input().split()))
edges = [[0]*n for _ in range(n)]
for _ in range(m):
L, R = [int(x)-1 for x in input().split()]
edges[L][R] += 1
for _ in range(q):
p, q = list(map(int, input().split()))
lines = edges[p-1:q]
print((sum(sum(row[p-1:q]) for row in lines))) | n, m, q = list(map(int, input().split()))
edges = [[0]*n for _ in range(n)]
for _ in range(m):
L, R = [int(x)-1 for x in input().split()]
edges[L][R] += 1
S = [[0]*(n+1)for _ in range(n+1)]
for i in range(n):
for j in range(n):
S[i][j+1] = S[i][j] + edges[i][j]
for _ in range(q):
p, q = list(map(int, input().split()))
lines = S[p-1:q]
ans = 0
for row in lines:
ans += row[q]-row[p-1]
print(ans) | p03283 |
n, m, q = list(map(int, input().split()))
edges = [[0]*n for _ in range(n)]
for _ in range(m):
L, R = [int(x)-1 for x in input().split()]
edges[L][R] += 1
S = [[0]*(n+1)for _ in range(n+1)]
for i in range(n):
for j in range(n):
S[i][j+1] = S[i][j] + edges[i][j]
for _ in range(q):
p, q = list(map(int, input().split()))
lines = S[p-1:q]
ans = 0
for row in lines:
ans += row[q]-row[p-1]
print(ans) | n, m, q = list(map(int, input().split()))
edges = [[0]*(n+1) for _ in range(n+1)]
for _ in range(m):
L, R = list(map(int, input().split()))
edges[L][R] += 1
for i in range(1, n+1):
for j in range(n):
edges[i][j+1] += edges[i][j]
for i in range(n):
for j in range(1, n+1):
edges[i+1][j] += edges[i][j]
for _ in range(q):
p, q = list(map(int, input().split()))
ans = edges[q][q]-edges[q][p-1]-edges[p-1][q]+edges[p-1][p-1]
print(ans) | p03283 |
class Ruiseki2D:
"""二次元累積和を構築する"""
def __init__(self, matrix):
self.h = len(matrix)
self.w = len(matrix[0])
self.ru = [[0] * (self.w + 1) for _ in range(self.h + 1)]
for i in range(self.h):
for j in range(self.w):
self.ru[i + 1][j + 1] = self.ru[i + 1][j] + matrix[i][j]
for i in range(self.h):
for j in range(self.w):
self.ru[i + 1][j + 1] += self.ru[i][j + 1]
def get_sum(self, hl, hr, wl, wr):
"""[hl, hr), [wl, wr) で囲まれた部分の和を求める"""
return (self.ru[hr][wr] + self.ru[hl][wl]
- self.ru[hr][wl] - self.ru[hl][wr])
n, m, q = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
query = [list(map(int, input().split())) for i in range(q)]
matrix = [[0] * (n + 1) for i in range(n + 1)]
for l, r in info:
matrix[l][r] += 1
ru = Ruiseki2D(matrix)
for l, r in query:
ans = ru.get_sum(l, r + 1, l, r + 1)
print(ans) | import sys
input = sys.stdin.readline
class Ruiseki2D:
"""二次元累積和を構築する"""
def __init__(self, matrix):
self.h = len(matrix)
self.w = len(matrix[0])
self.ru = [[0] * (self.w + 1) for _ in range(self.h + 1)]
for i in range(self.h):
for j in range(self.w):
self.ru[i + 1][j + 1] = self.ru[i + 1][j] + matrix[i][j]
for i in range(self.h):
for j in range(self.w):
self.ru[i + 1][j + 1] += self.ru[i][j + 1]
def get_sum(self, hl, hr, wl, wr):
"""[hl, hr), [wl, wr) で囲まれた部分の和を求める"""
return (self.ru[hr][wr] + self.ru[hl][wl]
- self.ru[hr][wl] - self.ru[hl][wr])
n, m, q = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
query = [list(map(int, input().split())) for i in range(q)]
matrix = [[0] * (n + 1) for i in range(n + 1)]
for l, r in info:
matrix[l][r] += 1
ru = Ruiseki2D(matrix)
for l, r in query:
ans = ru.get_sum(l, r + 1, l, r + 1)
print(ans) | p03283 |
n,m,q = list(map(int,input().split()))
c=[[0 for i in range(n+1)] for j in range(n+1)]
x=[[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()))
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)
| import sys
input = sys.stdin.readline
n,m,q = list(map(int,input().split()))
c=[[0 for i in range(n+1)] for j in range(n+1)]
x=[[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()))
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) | p03283 |
n, m, q = [int(x) for x in input().split()]
t_list = [[0] * (n + 1) for i in range(n + 1)]
c_list = [[0] * (n + 1) for i in range(n + 1)]
for _ in range(m):
l, r = [int(x) for x in input().split()]
t_list[l][r] += 1
for i in range(1, n + 1):
for j in range(1, n + 1):
c_list[i][j] = t_list[i][j] + c_list[i][j - 1]
for _ in range(q):
l, r = [int(x) for x in input().split()]
ans = 0
for j in range(l, r + 1):
ans += c_list[j][r] - c_list[j][l - 1]
print(ans) | n, m, q = [int(x) for x in input().split()]
t_list = [[0] * (n + 1) for i in range(n + 1)]
c_list = [[0] * (n + 1) for i in range(n + 1)]
for _ in range(m):
l, r = [int(x) for x in input().split()]
t_list[l][r] += 1
for i in range(1, n + 1):
for j in range(1, n + 1):
c_list[i][j] = t_list[i][j] + c_list[i][j - 1] + c_list[i - 1][j] - c_list[i - 1][j - 1]
for _ in range(q):
l, r = [int(x) for x in input().split()]
print((c_list[r][r] - c_list[l - 1][r] - c_list[r][l - 1] + c_list[l - 1][l - 1])) | p03283 |
from collections import Counter
from itertools import product
n,m,q = list(map(int,input().split()))
rails=[tuple(map(int,input().split())) for i in range(m)]
qs=[tuple(map(int,input().split())) for i in range(q)]
xlist = [[0 for j in range(n)] for i in range(n)]
sumlist = [[0 for j in range(n+1)] for i in range(n)]
sumsumlist = [[0 for j in range(n+1)] for i in range(n+1)]
for (l,r),i in list(Counter(rails).items()):
xlist[l-1][r-1]=i
for (i,j) in product(list(range(n)),list(range(n))):
sumlist[i][j+1]=sum(xlist[i][0:j+1])
for (i,j) in product(list(range(n)),list(range(n))):
sumsumlist[i+1][j+1] = sum([sumlist[l][j+1] for l in range(0,i+1)])
for (p,q) in qs:
ans = sumsumlist[q][q]- sumsumlist[q][p-1] -sumsumlist[p-1][q] + sumsumlist[p-1][p-1]
print(ans)
| from collections import Counter
from itertools import product
n,m,q = list(map(int,input().split()))
rails=[tuple(map(int,input().split())) for i in range(m)]
qs=[tuple(map(int,input().split())) for i in range(q)]
xlist = [[0 for j in range(n)] for i in range(n)]
sumlist = [[0 for j in range(n+1)] for i in range(n)]
sumsumlist = [[0 for j in range(n+1)] for i in range(n+1)]
for (l,r),i in list(Counter(rails).items()):
xlist[l-1][r-1]=i
for (i,j) in product(list(range(n)),list(range(n))):
sumlist[i][j+1]=sum(xlist[i][0:j+1])
for (i,j) in product(list(range(n)),list(range(n))):
sumsumlist[i+1][j+1] = sum([x[j+1] for x in sumlist[0:i+1]])
for (p,q) in qs:
ans = sumsumlist[q][q]- sumsumlist[q][p-1] -sumsumlist[p-1][q] + sumsumlist[p-1][p-1]
print(ans)
| p03283 |
n, m, q = list(map(int, input().split()))
image = [[0] * n for _ in range(n)]
for _ in range(m):
l, r = list(map(int, input().split()))
image[l - 1][r - 1] += 1
sumimage = [[0] * n for _ in range(n)]
for l in range(n - 1, -1, -1):
for r in range(l, n):
if l == r:
sumimage[l][r] = image[l][r]
else:
sumimage[l][r] = image[l][r] + sumimage[l + 1][r] + sumimage[l][r - 1] - sumimage[l + 1][r - 1]
for _ in range(q):
a, b = list(map(int, input().split()))
c = sumimage[a - 1][b - 1]
print(c) | n, m, q = list(map(int, input().split()))
image = [[0] * n for _ in range(n)]
for _ in range(m):
l, r = list(map(int, input().split()))
image[l - 1][r - 1] += 1
for l in range(n - 1, -1, -1):
for r in range(l + 1, n):
image[l][r] += image[l + 1][r] + image[l][r - 1] - image[l + 1][r - 1]
for _ in range(q):
a, b = list(map(int, input().split()))
c = image[a - 1][b - 1]
print(c) | p03283 |
#かいせつ
import itertools
n,m,q = list(map(int,input().split()))
lr = [[0 for i in range(n)] for j in range(n)]
for _ in range(m):
l,r = list(map(int,input().split()))
lr[l-1][r-1] += 1
acc_lr = []
for l in lr:
acc_lr.append([0] + list(itertools.accumulate(l)))
for _ in range(q):
l,r = list(map(int,input().split()))
ans = 0
for ls in acc_lr[l-1:r]:
ans += ls[r] - ls[l-1]
#print(ls,r,l-1)
print(ans)
| import itertools
n,m,q = list(map(int,input().split()))
lr = [[0 for i in range(n)] for j in range(n)]
for _ in range(m):
l,r = list(map(int,input().split()))
lr[l-1][r-1] += 1
acc_lr = []
for l in lr:
acc_lr.append([0] + list(itertools.accumulate(l)))
for _ in range(q):
l,r = list(map(int,input().split()))
ans = 0
for ls in acc_lr[l-1:r]:
ans += ls[r] - ls[l-1]
print(ans)
| p03283 |
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
def LILI(n): return [LI() for _ in range(n)]
INF = 10 ** 18
MOD = 10 ** 9 + 7
def main():
N, M, queries = LI()
L = []
R = []
for _ in range(M):
l, r = LI()
L.append(l)
R.append(r)
P = []
Q = []
for _ in range(queries):
p, q = LI()
P.append(p)
Q.append(q)
regions = [[] for _ in range(N+1)]
for l, r in zip(L, R):
regions[l].append(r-l)
for i in range(len(regions)):
regions[i] = sorted(regions[i])
from bisect import bisect_right
for p, q in zip(P, Q):
counter = 0
length = q-p
for station in range(p, q+1):
counter += bisect_right(regions[station], length)
length -= 1
print(counter)
main() | import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
def LILI(n): return [LI() for _ in range(n)]
INF = 10 ** 18
MOD = 10 ** 9 + 7
def main_old():
N, M, queries = LI()
L = []
R = []
for _ in range(M):
l, r = LI()
L.append(l)
R.append(r)
P = []
Q = []
for _ in range(queries):
p, q = LI()
P.append(p)
Q.append(q)
regions = [[] for _ in range(N+1)]
for l, r in zip(L, R):
regions[l].append(r-l)
regions_cumsum = [[0]*(N+1) for _ in range(N+1)]
for i in range(len(regions)): # [0,1,1,1,2,2] みたいなのを [1, 4, 6] と変換したい。
# まずはカウントする
cnt = [0]*(N+1)
for j in range(N+1):
cnt[regions[i][j]] += 1
# 続いて累積和を取る。
regions_cumsum[0] = cnt[0]
for j in range(1, N+1):
regions_cumsum[j] = regions_cumsum[j-1] + cnt[j]
from bisect import bisect_right
for p, q in zip(P, Q):
counter = 0
length = q-p
print((regions_cumsum[q] - regions_cumsum[p]))
# 駅番号: [そこから出る区間の長さのリスト] を持つ。
# クエリを駅番号・長さに持ち替えてソート。
# クエリごとに、駅番号において長さよりも短い電車が何本あるか見ていく。となりの駅に写ったら1引く。
# これでQ*N？
def main():
N, M, queries = LI()
L = []
R = []
for _ in range(M):
l, r = LI()
L.append(l)
R.append(r)
P = []
Q = []
for _ in range(queries):
p, q = LI()
P.append(p)
Q.append(q)
trains = [[0]*(N+1) for _ in range(N+1)]
for l, r in zip(L,R):
trains[l][r] += 1
cumsum = [[0]*(N+1) for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, N+1):
cumsum[i][j] = cumsum[i][j-1] + trains[i][j]
for p, q in zip(P, Q):
range_sum = 0
for i in range(p, q+1):
range_sum += cumsum[i][q] - cumsum[i][p-1]
print(range_sum)
main() | p03283 |
N, M, Q = list(map(int, input().split())) # 5 7 2
A=[]
for i in range(M):
l, r = list(map(int, input().split())) # 5 7
A.append( (l,r) )
#print(A)
for i in range(Q):
p, q = list(map(int, input().split())) # 5 7
ans=0
for a in A:
if (p<=a[0])and(a[1]<=q): ans+=1
else:
print(ans)
| N, M, Q = list(map(int, input().split())) # 5 7 2
A=[] # (l,r)をそのまま保持
B=[] # (l,r,n) lからrまでの本数nを保持, B[l][r]=n
for i in range(N+1):
a=[0]*(N+1)
B.append(a)
for i in range(M):
l, r = list(map(int, input().split())) # 5 7
A.append( (l,r) )
B[l][r]+=1
#print("A", A)
#print("B", B)
for iR in range(1,N+1):
for iC in range(1,N+1):
B[iR][iC] += B[iR][iC-1]
for iC in range(1,N+1):
for iR in range(iC, 1, -1):
B[iR-1][iC] += B[iR][iC]
#print("B", B)
for i in range(Q):
p, q = list(map(int, input().split())) # 5 7
print(( B[p][q] ))
| p03283 |
N, M, Q = [int(_) for _ in input().split()]
LR = [[int(_) for _ in input().split()] for _ in range(M)]
PQ = [[int(_) for _ in input().split()] for _ in range(Q)]
dp = [[0] * N for _ in range(N)]
for lr in LR:
dp[lr[0] - 1][lr[1] - 1] += 1
for pq in PQ:
print((sum([sum(dp[i][i:pq[1]]) for i in range(pq[0] - 1, pq[1])])))
| N, M, Q = [int(_) for _ in input().split()]
LR = [[int(_) for _ in input().split()] for _ in range(M)]
PQ = [[int(_) for _ in input().split()] for _ in range(Q)]
cumsum = [[0] * (N+2) for _ in range(N+1)]
for lr in LR:
cumsum[lr[0]][lr[0]] += 1
if lr[1] < N:
cumsum[lr[0]][lr[1]+1] -= 1
for i in range(N+1):
for j in range(i, N):
cumsum[i][j+1] += cumsum[i][j]
for pq in PQ:
print((sum([cumsum[i][i]-cumsum[i][pq[1]+1]
for i in range(pq[0], pq[1]+1)])))
| p03283 |
N, M, Q = list(map(int, input().split()))
x = [[0 for j in range(N + 1)] for i in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
x[N - L][R] += 1
for i in range(1, N + 1):
for j in range(1, N + 1):
x[i][j] += x[i][j - 1]
for j in range(1, N + 1):
for i in range(1, N + 1):
x[i][j] += x[i - 1][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((x[N - p][q]))
| N, M, Q = list(map(int, input().split()))
x = [[0 for j in range(N + 1)] for i in range(N + 1)]
for _ 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):
x[i][j] += x[i][j - 1]
for j in range(1, N + 1):
for i in reversed(list(range(1, N + 1))):
x[i - 1][j] += x[i][j]
for _ in range(Q):
p, q = list(map(int, input().split()))
print((x[p][q]))
| p03283 |
from bisect import bisect_left,bisect_right
N,M,Q=list(map(int,input().split()))
t=[list(map(int,input().split())) for _ in range(M)]
query=[list(map(int,input().split())) for _ in range(Q)]
train=[[0]*(N+1) for _ in range(N+1)]
c=[[0]*(N+1) for _ in range(N+1)]
for l,r in t:
train[l][r]+=1
for l in range(1,N+1):
for r in range(1,N+1):
c[l][r]=c[l][r-1]+train[l][r]
for p,q in query:
tmp=0
for l in range(p,q+1):
tmp+=c[l][q]-c[l][p-1]
print(tmp) | N,M,Q=list(map(int,input().split()))
t=[list(map(int,input().split())) for _ in range(M)]
query=[list(map(int,input().split())) for _ in range(Q)]
train=[[0]*(N+1) for _ in range(N+1)]
c=[[0]*(N+1) for _ in range(N+1)]
for l,r in t:
train[l][r]+=1
for l in range(1,N+1):
for r in range(1,N+1):
c[l][r]=c[l][r-1]+train[l][r]
for p,q in query:
tmp=0
for l in range(p,q+1):
tmp+=c[l][q]-c[l][p-1]
print(tmp) | p03283 |
N,M,Q=list(map(int,input().split()))
L,R=0,0
A=[[0]*(N+1) for i in range(N+1)]
for i in range(M):
L,R=list(map(int,input().split()))
A[L][R]+=1
B=[[0]*(N+1) for i in range(N+1)]
for i in range(N):
for j in range(N):
B[i+1][j+1]=B[i+1][j]+B[i][j+1]-B[i][j]+A[i+1][j+1]
for i in range(Q):
L,R=list(map(int,input().split()))
print((B[N][R]-B[L-1][R])) | N,M,Q=list(map(int,input().split()))
L,R=0,0
A=[[0]*(N+1) for i in range(N+1)]
for i in range(M):
L,R=list(map(int,input().split()))
A[L][R]+=1
C=[[0]*(N+1) for i in range(N+1)]
for i in range(1,N+1):
for j in range(1,N+1):
C[i][j]=C[i][j-1]+C[i-1][j]-C[i-1][j-1]+A[i][j]
for i in range(Q):
L,R=list(map(int,input().split()))
print((C[N][R]-C[L-1][R])) | p03283 |
from bisect import bisect_left
n, m, q = list(map(int, input().split()))
lrlist = [[int(x) for x in input().split()] for _ in range(m)]
pqlist = [[int(x) for x in input().split()] for _ in range(q)]
lrlist.sort(key=lambda lr: lr[1])
lrlist.sort(key=lambda lr: lr[0])
llist = [lr[0] for lr in lrlist]
rlist = [lr[1] for lr in lrlist]
pqilist = [[pqlist[i][0], pqlist[i][1], i] for i in range(q)]
pqilist.sort(key=lambda pqi: pqi[1])
pqilist.sort(key=lambda pqi: pqi[0])
cntlist = []
j = 0
for p, q, i in pqilist:
cnt = 0
j = bisect_left(llist, p, j)
for r in rlist[j:]:
if r <= q:
cnt += 1
cntlist.append((cnt, i))
cntlist.sort(key=lambda cnti: cnti[1])
for cnt, _ in cntlist:
print(cnt) | n, m, q = list(map(int, input().split()))
lr = [[0 for _ in range(n+1)] for _ in range(n+1)]
for _ in range(m):
l, r = list(map(int, input().split()))
lr[l][r] += 1
sumlr = [[0 for _ in range(n+1)] for _ in range(n+1)]
for l, r in ((l, r) for l in range(1, n+1) for r in range(1, n+1)):
sumlr[l][r] = lr[l][r] + sumlr[l-1][r] + sumlr[l][r-1] - sumlr[l-1][r-1]
for _ in range(q):
p, q = list(map(int, input().split()))
print((sumlr[q][q] - sumlr[p-1][q] - sumlr[q][p-1] + sumlr[p-1][p-1])) | p03283 |
import itertools
from collections import defaultdict
N,M,Q=list(map(int,input().split()))
d=defaultdict(int)
for i in range(M):
a,b=list(map(int,input().split()))
d[(a,b)]+=1
c={}
for x in range(0,N+1):
for y in range(0,x):
c[(x,y)]=0
c[(x,x)]=d[(x,x)]
for y in range(x+1,N+1):
c[(x,y)]=c[(x,y-1)]+d[(x,y)]
for i in range(Q):
x,y=list(map(int,input().split()))
print((sum(c[(j,y)]-c[(j,x-1)] for j in range(x,y+1)))) | N,M,Q=list(map(int,input().split()))
c=[[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()))
c[a][b]+=1
for i in range(1,N):
for j in range(1,N+1-i):
c[j][i+j]+=c[j+1][i+j]+c[j][i+j-1]-c[j+1][i+j-1]
for i in range(Q):
a,b=list(map(int,input().split()))
print((c[a][b])) | 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
ans = [[0 for _ in range(n+1)] for __ in range(n+1)]
for i in range(n):
for j in range(n+1):
ans[i+1][j] = ans[i][j] + train[i+1][j]
for j in range(n):
for i in range(n+1):
ans[i][j+1] = ans[i][j+1] + ans[i][j]
for __ in range(q):
p, q = list(map(int, input().split()))
print((ans[q][q] - ans[q][p-1] - ans[p-1][q] + ans[p-1][p-1])) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
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
ans = [[0 for _ in range(n+1)] for __ in range(n+1)]
for i in range(n):
for j in range(1, n+1):
ans[i+1][j] = ans[i][j] + train[i][j-1]
for j in range(n):
for i in range(n+1):
ans[i][j+1] = ans[i][j+1] + ans[i][j]
for __ in range(q):
p, q = list(map(int, input().split()))
print((ans[q][q] - ans[q][p-1] - ans[p-1][q] + ans[p-1][p-1]))
| p03283 |
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
# 二次元累積和(indexに注意)
s = [[0 for i in range(n+1)] for j in range(n+1)]
# s[x][y]:=[0,x-1]×[0,y-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] + lr[i+1][j+1]
for i in range(Q):
p,q = list(map(int,input().split()))
ans = s[q][q] - s[q][p-1] - s[p-1][q] + s[p-1][p-1]
print(ans)
# 72 | import sys
input = sys.stdin.readline
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
# 二次元累積和(indexに注意)
s = [[0 for i in range(n+1)] for j in range(n+1)]
# s[x][y]:=[0,x-1]×[0,y-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] + lr[i+1][j+1]
for i in range(Q):
p,q = list(map(int,input().split()))
ans = s[q][q] - s[q][p-1] - s[p-1][q] + s[p-1][p-1]
print(ans)
# 72
| p03283 |
from sys import stdin
from bisect import bisect_left
def getval():
n,m,q = list(map(int,stdin.readline().split()))
r = [list(map(int,stdin.readline().split())) for i in range(m)]
qu = [list(map(int,stdin.readline().split())) for i in range(q)]
return n,m,q,r,qu
def main(n,m,q,r,qu):
#Keep all railways sorted by their right index
rw = [[] for i in range(n)]
for i in r:
rw[i[1]-1].append(i[0]-1)
for i in range(n):
rw[i].sort()
#For each queries, iterate from rw[p-1] to rw[q-1] and bs for p-1
#print(rw)
for i in qu:
ans = 0
key = i[0]-1
for j in range(key,i[1]):
temp = rw[j]
ans += len(temp) - bisect_left(temp,key)
#print(mybs(rw[j],key),i)
print(ans)
if __name__=="__main__":
n,m,q,r,qu = getval()
main(n,m,q,r,qu) | from sys import stdin
from sys import stdout
def getval():
n,m,q = list(map(int,stdin.readline().split()))
r = [list(map(int,stdin.readline().split())) for i in range(m)]
qu = [list(map(int,stdin.readline().split())) for i in range(q)]
return n,m,q,r,qu
def main(n,m,q,r,qu):
#Keep all railways sorted by their right index
rw = [[] for i in range(n)]
for i in r:
rw[i[1]-1].append(i[0]-1)
for i in range(n):
rw[i].sort()
def mybs(arr,key):
lo = 0
hi = len(arr)-1
while lo<=hi:
idx = (lo+hi)//2
if arr[idx]<key:
lo = idx + 1
else:
hi = idx - 1
return lo
#For each queries, iterate from rw[p-1] to rw[q-1] and bs for p-1
#print(rw)
for i in qu:
ans = 0
key = i[0]-1
for j in range(key,i[1]):
ans += len(rw[j]) - mybs(rw[j],key)
#print(mybs(rw[j],key),i)
ans = "".join([str(ans),'\n'])
stdout.write(ans)
if __name__=="__main__":
n,m,q,r,qu = getval()
main(n,m,q,r,qu) | p03283 |
from sys import stdin
from sys import stdout
def getval():
n,m,q = list(map(int,stdin.readline().split()))
r = [list(map(int,stdin.readline().split())) for i in range(m)]
qu = [list(map(int,stdin.readline().split())) for i in range(q)]
return n,m,q,r,qu
def main(n,m,q,r,qu):
#Keep all railways sorted by their right index
rw = [[] for i in range(n)]
for i in range(m):
temp = r[i]
rw[temp[1]-1].append(temp[0]-1)
for i in range(n):
rw[i].sort()
def mybs(arr,key):
lo = 0
hi = len(arr)-1
while lo<=hi:
idx = (lo+hi)//2
if arr[idx]<key:
lo = idx + 1
else:
hi = idx - 1
return lo
#For each queries, iterate from rw[p-1] to rw[q-1] and bs for p-1
#print(rw)
for i in qu:
ans = 0
key = i[0]-1
for j in range(key,i[1]):
ans += len(rw[j]) - mybs(rw[j],key)
#print(mybs(rw[j],key),i)
ans = "".join([str(ans),'\n'])
stdout.write(ans)
if __name__=="__main__":
n,m,q,r,qu = getval()
main(n,m,q,r,qu) | from sys import stdin
from sys import stdout
def getval():
n,m,q = list(map(int,stdin.readline().split()))
rw = [[] for i in range(n)]
for i in range(m):
l,r = list(map(int,stdin.readline().split()))
rw[r-1].append(l-1)
for i in range(n):
rw[i].sort()
qu = [list(map(int,stdin.readline().split())) for i in range(q)]
return n,m,q,rw,qu
def main(n,m,q,rw,qu):
def mybs(arr,key):
lo = 0
hi = len(arr)-1
while lo<=hi:
idx = (lo+hi)//2
if arr[idx]<key:
lo = idx + 1
else:
hi = idx - 1
return lo
#For each queries, iterate from rw[p-1] to rw[q-1] and bs for p-1
#print(rw)
for i in qu:
ans = 0
key = i[0]-1
for j in range(key,i[1]):
ans += len(rw[j]) - mybs(rw[j],key)
#print(mybs(rw[j],key),i)
ans = "".join([str(ans),'\n'])
stdout.write(ans)
if __name__=="__main__":
n,m,q,rw,qu = getval()
main(n,m,q,rw,qu) | p03283 |
from sys import stdin
from sys import stdout
def getval():
n,m,q = list(map(int,stdin.readline().split()))
rw = [[] for i in range(n)]
for i in range(m):
l,r = list(map(int,stdin.readline().split()))
rw[r-1].append(l-1)
for i in range(n):
rw[i].sort()
return n,m,q,rw
def main(n,m,q,rw):
def mybs(arr,key):
lo = 0
hi = len(arr)-1
while lo<=hi:
idx = (lo+hi)//2
if arr[idx]<key:
lo = idx + 1
else:
hi = idx - 1
return lo
#For each queries, iterate from rw[p-1] to rw[q-1] and bs for p-1
#print(rw)
for i in range(q):
key,r = list(map(int,stdin.readline().split()))
key -= 1
ans = 0
for j in range(key,r):
temp = rw[j]
ans += len(temp) - mybs(temp,key)
ans = "".join([str(ans),'\n'])
stdout.write(ans)
if __name__=="__main__":
n,m,q,rw = getval()
main(n,m,q,rw) | from sys import stdin
from sys import stdout
def getval():
n,m,q = list(map(int,stdin.readline().split()))
rw = [[] for i in range(n)]
for i in range(m):
l,r = list(map(int,stdin.readline().split()))
rw[r-1].append(l-1)
for i in range(n):
rw[i].sort()
return n,m,q,rw
def main(n,m,q,rw):
def mybs(arr,key):
lo = 0
hi = len(arr)-1
while lo<=hi:
idx = (lo+hi)//2
if arr[idx]<key:
lo = idx + 1
else:
hi = idx - 1
return lo
#For each queries, iterate from rw[p-1] to rw[q-1] and bs for p-1
#print(rw)
for i in [0]*q:
key,r = list(map(int,stdin.readline().split()))
ans = 0
key -= 1
for j in range(key,r):
ans += len(rw[j]) - mybs(rw[j],key)
ans = "".join([str(ans),'\n'])
stdout.write(ans)
if __name__=="__main__":
n,m,q,rw = getval()
main(n,m,q,rw) | p03283 |
n,m,q=list(map(int,input().split()))
mylist=[[0]*(n+1) for _ in range(n+1)]
for i in range(m):
l,r=list(map(int,input().split()))
mylist[l][r]+=1
for i in range(1,n+1):
for j in range(1,n+1):
mylist[i][j]+=mylist[i][j-1]
memo=[[-1]*(n+1) for _ in range(n+1)]
for i in range(q):
P,Q=list(map(int,input().split()))
if(memo[P][Q]!=-1):
print((memo[P][Q]))
continue
tmp=0
for j in range(P,Q+1):
tmp+=mylist[j][Q]
memo[P][Q]=tmp
print(tmp) | n,m,q=list(map(int,input().split()))
mylist=[[0]*(n+1) for _ in range(n+1)]
for i in range(m):
l,r=list(map(int,input().split()))
mylist[l][r]+=1
for i in range(1,n+1):
for j in range(1,n+1):
mylist[i][j]+=mylist[i][j-1]
memo=[[-1]*(n+1) for _ in range(n+1)]
for i in range(q):
P,Q=list(map(int,input().split()))
if(memo[P][Q]!=-1):
print((memo[P][Q]))
continue
tmp=0
for j in range(Q,P-1,-1):
tmp+=mylist[j][Q]
memo[j][Q]=tmp
print(tmp) | p03283 |
N, M, Q = list(map(int, input().split()))
# LR = [list(map(int, input().split())) for i in range(M)]
Ls = [set() for i in range(N)]
Rs = [set() for i in range(N)]
for i in range(M):
L, R = list(map(int, input().split()))
Ls[L-1].add(i)
Rs[R-1].add(i)
for i in range(N-1):
j = N - 1 - i
Rs[i+1] |= Rs[i]
Ls[j-1] |= Ls[j]
for i in range(Q):
p, q = list(map(int, input().split()))
print((len(Ls[p-1] & Rs[q-1]))) | N, M, Q = list(map(int, input().split()))
Ls = [0] * N
Rs = [0] * N
for i in range(M):
L, R = list(map(int, input().split()))
Ls[L-1] |= 1 << i
Rs[R-1] |= 1 << i
for i in range(N-1):
j = N - 1 - i
Rs[i+1] |= Rs[i]
Ls[j-1] |= Ls[j]
for i in range(Q):
p, q = list(map(int, input().split()))
print((bin(Ls[p-1] & Rs[q-1]).count('1'))) | p03283 |
N, M, Q = list(map(int, input().split()))
Ls = [0] * N
Rs = [0] * N
for i in range(M):
L, R = list(map(int, input().split()))
Ls[L-1] |= 1 << i
Rs[R-1] |= 1 << i
for i in range(N-1):
j = N - 1 - i
Rs[i+1] |= Rs[i]
Ls[j-1] |= Ls[j]
for i in range(Q):
p, q = list(map(int, input().split()))
print((bin(Ls[p-1] & Rs[q-1]).count('1'))) | N, M, Q = list(map(int, input().split()))
MAP = [[0] * N for i in range(N)]
for i in range(M):
L, R = list(map(int, input().split()))
MAP[L-1][R-1] += 1
for r in range(N):
for l in range(N-1, 0, -1):
MAP[l-1][r] += MAP[l][r]
for r in range(N-1):
for l in range(N):
MAP[l][r+1] += MAP[l][r]
for i in range(Q):
p, q = list(map(int, input().split()))
print((MAP[p-1][q-1])) | p03283 |
import sys
sys.setrecursionlimit(1000000)
N,M,Q = [int(x) for x in input().split()]
lr = [[int(x) for x in input().split()]for _ in range(M)]
pq = [[int(x) for x in input().split()]for _ in range(Q)]
dp = [[0 for _ in range(N+1)]for _ in range(N+1)]
for i in lr:
for j in range(i[0]+1):
dp[j][i[1]]+=1
for i in range(N,0,-1):
for j in range(i,N+1):
if(j!=i):
dp[i][j] += dp[i][j-1]
for i in pq:
print((dp[i[0]][i[1]])) | import sys
sys.setrecursionlimit(1000000)
N,M,Q = [int(x) for x in input().split()]
lr = [[int(x) for x in input().split()]for _ in range(M)]
pq = [[int(x) for x in input().split()]for _ in range(Q)]
dp = [[0 for _ in range(N+1)]for _ in range(N+1)]
for i in lr:
dp[i[0]][i[1]]+=1
for j in range(N+1):
for i in range(N-1,0,-1):
dp[i][j] += dp[i+1][j]
for i in range(N,0,-1):
for j in range(i,N+1):
if(j!=i):
dp[i][j] += dp[i][j-1]
for i in pq:
print((dp[i[0]][i[1]])) | p03283 |
# あらかじめ全ての区間における答えを求めておく
# 累積和が使える。
# p,qの値に関しての2次元座標系で考えると、値が存在するマスは限られてる
#
#
n, m, q = list(map(int, input().split()))
ll = [[0, 0] for i in range(m)]
p = [[0, 0] for i in range(q)]
for i in range(m):
ll[i][0], ll[i][1] = list(map(int, input().split()))
for i in range(q):
p[i][0], p[i][1] = list(map(int, input().split()))
# for i in range(m):
# print(ll[i])
# for i in range(q):
# print(p[i])
sum = [[0 for i in range(n)] for i in range(n)]
# sum上でlをy成分＝行、rをx成分=列とする。
for j in range(m):
y = ll[j][0]-1
x = ll[j][1]-1
sum[y][x] += 1
ans = [[0 for i in range(n)] for i in range(n)]
for i in range(n):
for j in range(i, n):
for i2 in range(i, j+1):
for j2 in range(i, j+1):
ans[i][j] += sum[j2][i2]
for i in range(q):
y = p[i][0]-1
x = p[i][1]-1
print((ans[y][x]))
| # あらかじめ全ての区間における答えを求めておく
# 累積和が使える。
# 2次元累積和に関しては、下記のサイトを参照。
# https://paiza.hatenablog.com/entry/2014/05/28/もし女子大生プログラマに『アルゴリズム』を図
# p,qの値に関しての2次元座標系で考えると、値が存在するマスは限られてる
#
#
n, m, q = list(map(int, input().split()))
ll = [[0, 0] for i in range(m)]
p = [[0, 0] for i in range(q)]
for i in range(m):
ll[i][0], ll[i][1] = list(map(int, input().split()))
for i in range(q):
p[i][0], p[i][1] = list(map(int, input().split()))
# for i in range(m):
# print(ll[i])
# for i in range(q):
# print(p[i])
sum = [[0 for i in range(n)] for i in range(n)]
# sum上でlをy成分＝行、rをx成分=列とする。
# 各区間の値を取り込み
for j in range(m):
x = ll[j][0]-1
y = ll[j][1]-1
sum[y][x] += 1
# 2次元累積和の計算
# for j in range(n):
# print(sum[j])
# print('-'*30)
for i in range(n):
for j in range(1, n):
sum[i][j] += sum[i][j-1]
for i in range(n):
for j in range(1, n):
sum[j][i] += sum[j-1][i]
# ans = [[0 for i in range(n)] for i in range(n)]
# for i in range(n):
# for j in range(i, n):
# for i2 in range(i, j+1):
# for j2 in range(i, j+1):
# ans[i][j] += sum[j2][i2]
# for j in range(n):
# print(sum[j])
for i in range(q):
x = p[i][0]-1
y = p[i][1]-1
if x != 0:
print((sum[y][y] - sum[y][x-1] - sum[x-1][y]+sum[x-1][x-1]))
else:
print((sum[y][y]))
| p03283 |
N, M, Q = list(map(int, input().split(' ')))
st_ed = {}
for i in range(M):
l, r = list(map(int, input().split(' ')))
st_ed[(l, r)] = st_ed.get((l, r), 0) + 1
memo_s = {}
# memo[(p, q)] = memo[(p, q-1)] + sum([st_ed.get((i, q), 0) for i in [1,2,3...p]])
def f(p, q):
if p == q:
return st_ed.get((p, q), 0)
if not (p, q) in memo_s:
temp = f(p, q - 1)
for i in range(p, q + 1):
temp += st_ed.get((i, q), 0)
memo_s[(p, q)] = temp
return memo_s[(p, q)]
memo = {}
for i in range(Q): # 1e5
p, q = list(map(int, input().split(' ')))
if not (p, q) in memo:
temp = f(p, q)
memo[(p, q)] = temp
print((memo[(p, q)]))
| N, M, Q = list(map(int, input().split(' ')))
st_ed = {}
for i in range(M):
l, r = list(map(int, input().split(' ')))
st_ed[(l, r)] = st_ed.get((l, r), 0) + 1
memo_g = {}
def g(p, q):
if p == q:
return st_ed.get((p, q), 0)
if not (p, q) in memo_g:
memo_g[(p, q)] = st_ed.get((p, q), 0) + g(p + 1, q)
return memo_g[(p, q)]
memo_f = {}
# memo[(p, q)] = memo[(p, q-1)] + sum([st_ed.get((i, q), 0) for i in [1,2,3...p]])
def f(p, q):
if p == q:
return st_ed.get((p, q), 0)
if not (p, q) in memo_f:
temp = f(p, q - 1) + g(p, q)
memo_f[(p, q)] = temp
return memo_f[(p, q)]
memo = {}
for i in range(Q): # 1e5
p, q = list(map(int, input().split(' ')))
if not (p, q) in memo:
temp = f(p, q)
memo[(p, q)] = temp
print((memo[(p, q)]))
| p03283 |
def main():
n, m, q = list(map(int, input().split()))
trains = [list(map(int, input().split())) for _ in range(m)]
questions = [list(map(int, input().split())) for _ in range(q)]
for question in questions:
a, b = question
# result = [train for train in trains if a <= train[0] and train[1] <= b]
result = list([x for x in trains if a <= x[0] and x[1] <= b])
print((len(result)))
if __name__ == '__main__':
main()
| n, m, q = list(map(int, input().split()))
cities = [[0 for _ in range(n+1)] for _ in range(n+2)]
trains = [list(map(int, input().split())) for _ in range(m)]
quests = [list(map(int, input().split())) for _ in range(q)]
for train in trains:
x, y = train[0], train[1]
cities[x][y] += 1
for i in range(n):
for j in range(1, n-i+1):
x = j + i
cities[j][x] += cities[j][x-1] + cities[j+1][x] - cities[j+1][x-1]
for quest in quests:
p, q = quest[0], quest[1]
print((cities[p][q]))
| p03283 |
#!/usr/bin/env python3
import sys
import itertools
import collections
import functools
import math
from queue import Queue
# import numpy as np
INF = float("inf")
def solve(N: int, M: int, Q: int, L: "List[int]", R: "List[int]", p: "List[int]", q: "List[int]"):
a = [[0]*(N+1) for _ in range(N+1)]
for l, r in zip(L, R):
a[l][r] += 1
for i in range(1, N+1):
a[i] = list(itertools.accumulate(a[i]))
for pp, qq in zip(p, q):
print((int(sum([a[i][qq]-a[i][pp-1] for i in range(pp, qq+1)]))))
# print(a)
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
import itertools
import collections
import functools
import math
from queue import Queue
# import numpy as np
INF = float("inf")
def solve(N: int, M: int, Q: int, L: "List[int]", R: "List[int]", p: "List[int]", q: "List[int]"):
a = [[0]*(N+1) for _ in range(N+1)]
for l, r in zip(L, R):
a[l][r] += 1
a = [list(itertools.accumulate(x)) for x in a]
a = [list(itertools.accumulate(s[::-1]))[::-1] for s in zip(*a)]
for pp, qq in zip(p, q):
# 転置略して逆指定
print((a[qq][pp]))
# print(*a, sep="\n")
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 |
n, m, q = list(map(int, input().split()))
train = [tuple(map(int, input().split())) for _ in range(m)]
quest = [tuple(map(int, input().split())) for _ in range(q)]
dp = [[0 for _ in range(n)] for _ in range(n)]
d = {}
for l in range(n):
for r in range(l,n):
d[(l,r)] = 0
for p, q in train:
d[(p-1,q-1)] += 1
for l in range(n):
dp[l][l] = d[(l,l)]
for w in range(1,n):
for l in range(n-w):
add = 0
for addl in range(l,l+w+1):
add += d[(addl, l+w)]
dp[l][l+w] = dp[l][l+w-1] + add
for l, r in quest:
print((dp[l-1][r-1]))
| n, m, q = list(map(int, input().split()))
train = [tuple(map(int, input().split())) for _ in range(m)]
quest = [tuple(map(int, input().split())) for _ in range(q)]
dp = [[0 for _ in range(n+1)] for _ in range(n+1)]
d = {}
for l in range(n):
for r in range(l,n):
d[(l+1,r+1)] = 0
for p, q in train:
d[(p,q)] += 1
for l in range(1,n+1):
dp[l][l] = d[(l,l)]
for w in range(1,n):
for l in range(n-w):
dp[l+1][l+w+1] = dp[l+1][l+w] + dp[l+2][l+w+1] - dp[l+2][l+w] + d[(l+1,l+w+1)]
for l, r in quest:
print((dp[l][r]))
| p03283 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.