input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from operator import add
class BIT():
def __init__(self, length_or_list, func, e):
self.func = func
self.e = e
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [self.e] * self.n
else:
self.n = len(length_or_l... | from operator import add
import sys
input = sys.stdin.buffer.readline
class BIT():
def __init__(self, length_or_list, func, e):
self.func = func
self.e = e
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [self.e] * self.n
... | p02599 |
N, Q = list(map(int, input().split()))
Color = [0] + list(map(int, input().split()))
Query =[]
for i in range(Q):
l, r = list(map(int, input().split()))
Query.append((r, l, i))
Query.sort()
Ans = [0] * Q
BIT = [0] * (N + 1) # BITを使う
def BIT_query(idx): # idxまでの合計を返す
res_sum = 0
while ... | import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
Color = [0] + list(map(int, input().split()))
Query =[]
for i in range(Q):
l, r = list(map(int, input().split()))
Query.append(r * 10 ** 12 + l * 10 ** 6 + i)
Query.sort()
Ans = [0] * Q
BIT = [0] * (N + 1) # BITを使... | p02599 |
class BinaryIndexedTree:
def __init__(self, size=10**7):
self.size = size
self.data = [0]*(size+1)
def add(self, index, x):
while index <= self.size:
self.data[index] += x
index += index & -index
def sum(self, index):
res = 0
whil... | class BinaryIndexedTree:
def __init__(self, size=10**7):
self.size = size
self.data = [0]*(size+1)
def add(self, index, x):
while index <= self.size:
self.data[index] += x
index += index & -index
def prefix_sum(self, index):
res = 0
... | p02599 |
class BinaryIndexedTree:
def __init__(self, size=10**7):
self.size = size
self.data = [0]*(size+1)
def add(self, index, x):
while index <= self.size:
self.data[index] += x
index += index & -index
def prefix_sum(self, index):
res = 0
... | class BinaryIndexedTree:
def __init__(self, size=10**7):
self.size = size
self.data = [0]*(size+1)
def add(self, index, x):
while index <= self.size:
self.data[index] += x
index += index & -index
def prefix_sum(self, index):
res = 0
... | p02599 |
# Python3 code to find number of
# distinct numbers in a subarray
MAX = 500001
# structure to store queries
class Query:
def __init__(self, l, r, idx):
self.l = l
self.r = r
self.idx = idx
# updating the bit array
def update(idx, val, bit, n):
while idx <= n... | import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# Python3 code to find number of
# distinct numbers in a subarray
MAX = 500001
# structure to store queries
class Query:
def __init__(self, l, r, idx):
self.l = l
self.r = r
self.idx = idx
# up... | p02599 |
import sys
input = sys.stdin.readline
from collections import *
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def add(self, i, x):
i += 1
while i<=self.n:
self.bit[i] += x
i += i&(-i)
def acc(self, i)... | import sys
input = sys.stdin.readline
from collections import *
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def add(self, i, x):
i += 1
while i<=self.n:
self.bit[i] += x
i += i&(-i)
def acc(self, i)... | p02599 |
import sys
input = sys.stdin.readline
from collections import *
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def add(self, i, x):
i += 1
while i<=self.n:
self.bit[i] += x
i += i&(-i)
def acc(self, i)... | import sys
input = sys.stdin.readline
from collections import *
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(n+1)
def add(self, i, x):
i += 1
while i<=self.n:
self.bit[i] += x
i += i&(-i)
def acc(self, i)... | p02599 |
class BIT:
# 1-indexed
def __init__(self, n):
self.size = n + 1
self.bit = [0] * self.size
def add(self, i, x):
"""Add x to a[i]."""
while i < self.size:
self.bit[i] += x
i += i & -i
def sumup(self, i):
"""Sum a[1]~a[i]."""
... |
class BIT:
# 1-indexed
def __init__(self, n):
self.size = n + 1
self.bit = [0] * self.size
def add(self, i, x):
# Add x to a[i]
while i < self.size:
self.bit[i] += x
i += i & -i
def sumup(self, i):
# Sum a[1]~a[i]
... | p02599 |
import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
... | import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
... | p02599 |
import sys
input = sys.stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.se... | from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | p02599 |
from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | p02599 |
from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | p02599 |
from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | p02599 |
from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | p02599 |
from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | p02599 |
from sys import stdin
input = stdin.readline
class SegTree():
def segfunc(self, x, y):
return x+y
def __init__(self, ide, n, init_val):
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
... | from sys import stdin
input = stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
w... | p02599 |
class BinaryIndexedTree(): #1-indexed
def __init__(self, n):
self.n = n
self.tree = [0 for _ in range(n + 1)]
def sum(self, idx):
res = 0
while idx:
res += self.tree[idx]
idx -= idx & -idx
return res
def add(self, idx, x):
... | import sys
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
C = list([int(x) - 1 for x in input().split()])
query = []
for i in range(Q):
l, r, = list(map(int, input().split()))
query.append((l - 1, r, i))
query.sort(key = lambda x: x[1])
rt = 0
L = [None for _ in ran... | p02599 |
N, Q = map(int, input().split())
A = list(map(int, input().split()))
MAX_A = 5 * 10 ** 5
query = []
for q in range(Q):
l, r = map(int, input().split())
query.append((l, r, q))
# 一番後ろの1を削りながら0までやるイメージ
# 1-indexed
# 閉区間
# 区間[s, t]の和 => BIT.add(t) - BIT.add(s - 1)
class BinaryIndexedTree:
def... | def main():
import sys
my_input = sys.stdin.readline
N, Q = list(map(int, my_input().split()))
A = list(map(int, my_input().split()))
MAX_A = 5 * 10 ** 5
query = []
for q in range(Q):
l, r = list(map(int, my_input().split()))
query.append((l, r, q))
class Bi... | p02599 |
import sys
from bisect import bisect_right
from math import ceil
def input(): return sys.stdin.readline().strip()
class BIT:
"""
https://tjkendev.github.io/procon-library/python/range_query/bit.html
Binary index treeの実装
1-indexedの配列[a1, a2,...,an]に対して以下のクエリをO(logn)で行う:
1. aiにxを加える
... | import sys
from bisect import bisect_right
from math import ceil
def input(): return sys.stdin.readline().strip()
class BIT:
"""
https://tjkendev.github.io/procon-library/python/range_query/bit.html
Binary index treeの実装
1-indexedの配列[a1, a2,...,an]に対して以下のクエリをO(logn)で行う:
1. aiにxを加える
... | p02599 |
import sys, heapq
input = sys.stdin.readline
n, q = map(int, input().split())
c = [int(x) - 1 for x in input().split()]
que = []
for i in range(q):
l, r = map(int, input().split())
heapq.heappush(que, (r-1, l-1, i))
bit = [0 for _ in range(n)]
#####segfunc#####
def segfunc(x, y):
return x... | import sys, heapq
input = sys.stdin.readline
n, q = map(int, input().split())
c = [int(x) - 1 for x in input().split()]
que = []
for i in range(q):
l, r = map(int, input().split())
que.append((l, r, i))
class SegTree(object):
def __init__(self, n):
self.BIT = [0] * (n + 1)
... | p02599 |
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
a = list(map(int, input().split()))
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... | import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
a = list(map(int, input().split()))
class SegTree:
def segfunc(self, x, y):
return x + y
def __init__(self, n, ide_ele, init_val):
#####単位元######
self.ide_ele = ide_ele
#num:n以上の最小の2のべき乗
self.num = 2 ** (n ... | p02599 |
import sys
input=sys.stdin.readline
class BIT:
def __init__(self,n):
self.n=n+1
self.BIT=[0]*self.n
def add(self,i,x):
idx=i
while idx<self.n:
self.BIT[idx]+=x
idx+=(idx&-idx)
def _sum(self,i):
ret=0
idx=i
while idx>0:
ret+=self.BIT[idx]
idx-=(... | import sys
input=sys.stdin.readline
class BIT:
def __init__(self,n):
self.n=n+1
self.BIT=[0]*self.n
def add(self,i,x):
idx=i
while idx<self.n:
self.BIT[idx]+=x
idx+=(idx&-idx)
def _sum(self,i):
ret=0
idx=i
while idx>0:
ret+=self.BIT[idx]
idx-=(... | p02599 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 =... | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 =... | p02599 |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | '''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | p02599 |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | '''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | p02599 |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | '''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | p02599 |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | '''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecurs... | p02599 |
# 解説の解法はAtCoder expressみたいな二次元累積和っぽい考え方を平面走査とBIT(セグ木)で高速化
# ここではとりあえず遅延セグ木を用いてけんちょんさんの解法を投げてみる https://drken1215.hatenablog.com/entry/2019/01/01/234400
# 遅延セグ木がTLEしたので,BITで...
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0] * (self.n + 1) # bitは(1based indexっぽい感じなので)
de... | # 解説の解法はAtCoder expressみたいな二次元累積和っぽい考え方を平面走査とBIT(セグ木)で高速化
# ここではとりあえず遅延セグ木を用いてけんちょんさんの解法を投げてみる https://drken1215.hatenablog.com/entry/2019/01/01/234400
# 遅延セグ木がTLEしたので,BITで...
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0] * (self.n + 1) # bitは(1based indexっぽい感じなので)
de... | p02599 |
def solve():
n, q = list(map(int, input().split()))
s = list(map(int, input().split()))
cnt = []
rcnt = []
for i in range(1, n + 1):
x = len(set(s[:i]))
cnt.append(x)
for i in range(n - 1, -1, -1):
x = len(set(s[i:]))
rcnt.append(x)
rcnt = rcnt[::-1... | def solve():
import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * n
def sum(self, i):
s = 0
while i > 0:
s += self.data[i - 1]
i &= i - 1
... | p02599 |
#!/usr/bin/env python3
class BinaryIndexedTree:
def __init__(self, size):
"""
:param int size:
"""
self.bit = [0 for _ in range(size)]
self.size = size
def add(self, i, w):
"""
i番目にwを加える
:param int i:
:param int w:
:... | #!/usr/bin/env python3
import sys
class BinaryIndexedTree:
def __init__(self, size):
"""
:param int size:
"""
self.bit = [0 for _ in range(size)]
self.size = size
def add(self, i, w):
"""
i番目にwを加える
:param int i:
:param int w... | p02599 |
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
... | class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
... | p02599 |
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
... | class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
... | p02599 |
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
... | class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
... | p02599 |
#A1 ~ Aiまでの和 O(logN)
def BIT_query(BIT,idx):
res_sum = 0
if idx == 0:
return 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(BIT,idx,x,n):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
... | #A1 ~ Aiまでの和 O(logN)
def BIT_query(BIT,idx):
res_sum = 0
if idx == 0:
return 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(BIT,idx,x,n):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
... | p02599 |
N,Q = list(map(int,input().split()))
c = [-1]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for i in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**15+l*10**8+i)
queries.sort()
curR = 0
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(N+1)
#A1 ~ Aiまでの和 ... | N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
c = [-1]+list(map(... | p02599 |
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
c = [-1]+list(map(... | N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
c = [-1]+list(map(... | p02599 |
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
c = [-1]+list(map(... | import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx ... | p02599 |
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
id... | import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
id... | p02599 |
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
id... | import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx ... | p02599 |
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx ... | import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int,input().split()))
BIT = [0]*(N+1) # BITを使う
def BIT_query(idx): # idxまでの合計を返す
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x): # idxにxを足す
while idx <= ... | p02599 |
class BIT: # 1Indexed
def __init__(self,size):
self.array = [0]*size
self.size = size
def add(self,ind,value):
while ind <= self.size:
self.array[ind-1] += value
ind += ind & -ind
def sum(self,x):
out = 0
while x > 0:
ou... | class BIT: # 1Indexed
def __init__(self,size):
self.array = [0]*size
self.size = size
def add(self,ind,value):
while ind <= self.size:
self.array[ind-1] += value
ind += ind & -ind
def sum(self,x):
out = 0
while x > 0:
ou... | p02599 |
from operator import itemgetter
import sys
def read():
return sys.stdin.readline().rstrip()
def add(arr, i, x):
while i < len(arr):
arr[i] += x
i += i & -i
def range_sum(arr, a, b):
s = 0
i = b
while i > 0:
s += arr[i]
i -= i & -i
i = a -... | from operator import itemgetter
import sys
def read():
return sys.stdin.readline().rstrip()
def add(arr, i):
while i < len(arr):
arr[i] += 1
i += i & -i
def sub(arr, i):
while i < len(arr):
arr[i] -= 1
i += i & -i
def range_sum(arr, a, b):
s =... | p02599 |
def main():
import sys
input = sys.stdin.buffer.readline
N, Q = map(int, input().split())
*C, = map(int, input().split())
last = [-1]*(N+1)
P = [[] for _ in [0]*(N+1)]
for i, c in enumerate(C):
if last[c] != -1:
P[last[c]].append(i+1)
last[c] = i+1
... | def main():
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N, Q = map(int, input().split())
*C, = map(int, input().split())
last = [-1]*(N+1)
P = [[] for _ in [0]*(N+1)]
for i, c in enumerate(C):
if last[c] != -1:
P[last[c]].append(i+1)
... | p02599 |
# Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# Fenwick Tree to Calculate Sum
N,Q = list(map(int,input().split()))
MaxLength = 2 ** 19
FenwickTree = []
CurLen = MaxLength
while CurLen != 0:
FenwickTree.append([0] * CurLen)
CurLen... | # Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# Fenwick Tree to Calculate Sum
N,Q = list(map(int,input().split()))
MaxLength = N
FenwickTree = []
CurLen = MaxLength
while CurLen != 0:
FenwickTree.append([0] * CurLen)
CurLen //= 2... | p02599 |
import sys
input = sys.stdin.readline
from collections import Counter
def read():
N, Q = list(map(int, input().strip().split()))
C = list(map(int, input().strip().split()))
LR = []
for i in range(Q):
l, r = list(map(int, input().strip().split()))
LR.append((l, r))
retur... | import sys
input = sys.stdin.readline
from collections import Counter
def read():
N, Q = list(map(int, input().strip().split()))
C = list(map(int, input().strip().split()))
LR = []
for i in range(Q):
l, r = list(map(int, input().strip().split()))
LR.append((l-1, r))
ret... | p02599 |
import sys
input = sys.stdin.readline
from collections import Counter
def read():
N, Q = list(map(int, input().strip().split()))
C = list(map(int, input().strip().split()))
LR = []
for i in range(Q):
l, r = list(map(int, input().strip().split()))
LR.append((l-1, r))
ret... | import sys
input = sys.stdin.readline
from operator import add, itemgetter
class RMQ():
def __init__(self, size, op=min, init_value=10**8):
"""初期化"""
self.size = size
self.op = op
self.init_value = init_value
n = 2 ** ((size-1).bit_length())
treesi... | p02599 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
class BinaryIndexTree:
def __init__(self, n):
self.size = n
self._container = [0] * (n + 1)
self.depth = n.bit_length()
def sum(self, i):
if i == 0:
... | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from operator import itemgetter
class BinaryIndexTree:
def __init__(self, n):
self.size = n
self._container = [0] * (n + 1)
self... | p02599 |
from operator import itemgetter
class BinaryIndexedTree: # 0-index !!!
"""
init(n): 要素数nを与えて0で初期化
add(i, x): i番目の値にxを追加 O(logN)
sum(i): 区間[0,i)の和を返す O(logN)
query(l, r): 区間[l,r)の和を返す O(logN)
"""
def __init__(self, n):
self.size = n
self.tree = [0] * ... | import sys
from operator import itemgetter
def input(): return sys.stdin.readline().rstrip()
class BinaryIndexedTree: # 0-index !!!
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1) # 内部的には1-indexで扱う
def add(self, i, x): # 0-index
i += 1 # 内部的には1-indexで扱う
... | p02599 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
... | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
... | p02599 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
... | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
... | p02599 |
import sys
input = sys.stdin.buffer.readline
n,Q = list(map(int,input().split()))
c = list(map(int,input().split()))
#####segfunc######
def segfunc(x,y):
return x|y
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... | import sys
input = sys.stdin.buffer.readline
n,Q = map(int,input().split())
c = [0] + list(map(int,input().split()))
dg = 10**6
dg2 = 10**12
res = [0]*Q
LRI = []
for i in range(Q):
l,r = map(int,input().split())
LRI.append(l*dg2 + r*dg + i)
LRI.sort()
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
... | p02599 |
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] +=... | from sys import stdin
input = stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
... | p02599 |
# from sys import stdin
# input = stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
... | from sys import stdin
input = stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
... | p02599 |
SHIFT = 1 << 20
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = []
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query.append(ri << 40 | le << 20 | j)
Query.sort()
# Query復元
for i in range(Q):
... | SHIFT = 1 << 20
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = []
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query.append(ri << 40 | le << 20 | j)
Query.sort()
# Query復元
for i in range(Q):
... | p02599 |
SHIFT = 1 << 20
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = []
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query.append(ri << 40 | le << 20 | j)
Query.sort()
# Query復元
for i in range(Q):
... | SHIFT = 1 << 20
class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N+1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i... | p02599 |
class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N+1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & (-i)
retu... | class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N+1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & (-i)
retu... | p02599 |
import sys
input = sys.stdin.readline
n,q= list(map(int,input().split()))
A = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(q)]
for i in range(q):
print((len(set(A[C[i][0]-1:C[i][1]])))) | import sys
input = sys.stdin.readline
n,q= list(map(int,input().split()))
A = list(map(int,input().split()))
C = [list(map(int,input().split())) + [i] for i in range(q)]
for i in range(q):
C[i][0] -= 1
C[i][1] -= 1
for i in range(n):
A[i] -= 1
class Bit:
def __init__(self, n):
self... | p02599 |
class BinaryIndexedTree:
def __init__(self, size):
self.data = [0] * (size+1)
self.msb = 1 << (size.bit_length()-1)
def _add(self, i, w):
i += 1
while i < len(self.data):
self.data[i] += w
i += i & -i
def _get_sum(self, i):
... | class BinaryIndexedTree:
def __init__(self, size):
self.data = [0] * (size+1)
self.size = size+1
self.msb = 1 << (size.bit_length()-1)
def _add(self, i, w):
i += 1
while i < self.size:
self.data[i] += w
i += i & -i
def _ge... | p02599 |
class BinaryIndexedTree:
def __init__(self, size):
self.data = [0] * (size+1)
self.size = size+1
self.msb = 1 << (size.bit_length()-1)
def _add(self, i, w):
i += 1
while i < self.size:
self.data[i] += w
i += i & -i
def _ge... | class BinaryIndexedTree:
def __init__(self, size):
self.data = [0] * (size+1)
self.size = size+1
self.msb = 1 << (size.bit_length()-1)
def _add(self, i, w):
i += 1
while i < self.size:
self.data[i] += w
i += i & -i
def _ge... | p02599 |
from operator import add, mul, sub, or_
class SegmentTree:
'''
セグメント木(遅延ではない)
1-indexd セグメント木
values : 値の配列
op : 区間に対する関数
ie : 初期値
'''
def __init__(self, values, op, ie):
self.values = values
vlen = len(values)
self.op = op
self.size = 2... | from operator import add, mul, sub, or_
class SegmentTree:
'''
セグメント木(遅延ではない)
1-indexd セグメント木
values : 値の配列
op : 区間に対する関数
ie : 初期値
'''
def __init__(self, values):
self.values = values
vlen = len(values)
self.size = 2 ** (vlen-1).bit_length()
... | p02599 |
from operator import add, mul, sub, or_
class SegmentTree:
'''
セグメント木(遅延ではない)
1-indexd セグメント木
values : 値の配列
op : 区間に対する関数
ie : 初期値
'''
def __init__(self, values):
self.values = values
vlen = len(values)
self.size = 2 ** (vlen-1).bit_length()
... | class BIT:
def __init__(self, n):
self.n = n
self.tree = [0]*(n+1)
def update(self, i, v):
while i <= self.n:
self.tree[i] += v
i += i & (-i)
def query(self, i):
v = 0
while i:
v += self.tree[i]
i -= i & ... | p02599 |
from operator import add, mul, sub, or_
class BIT:
def __init__(self, n, op, ie):
self.n = n
self.tree = [ie]*(n+1)
self.op = op
def update(self, i, v):
while i <= self.n:
self.tree[i] = self.op(self.tree[i], v)
i += i & -i
def query(... | from operator import add, mul, sub, or_
class BIT:
def __init__(self, n, op, ie):
self.n = n
self.tree = [ie]*(n+1)
self.op = op
self.ie = ie
def update(self, i, v):
while i <= self.n:
self.tree[i] = self.op(self.tree[i], v)
i += i ... | p02599 |
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from bisect import bisect
def resolve():
it = map(int, sys.stdin.read().split())
N, Q = next(it), next(it)
C = [next(it) for i in range(N)]
D = list(zip(it, it, range(Q)))
D.sort(key=lambda x: (x[1], x[... | #!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def resolve():
it = map(int, sys.stdin.read().split())
X = 19
N, Q = next(it), next(it)
X = Q.bit_length()
b1, br, bc = (1 << X)-1, 2*X+1, 1<<X
Aa = [next(it)-1 for i in range(N)]
Aq = [0] * Q
... | p02599 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in ... | import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in ... | p02599 |
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.n = n
self.tree = [0]*(n+1)
self.elem = [0] * (n + 1)
self.depth = n.bit_length() - 1
def sum(self, i):
""" 区間[0,i) の総和を求める """
s = 0
i -= 1
while i >= 0:
... | import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
"""
:param n: 最大の要素数
"""
self.n = n
self.tree = [0]*(n+1)
self.depth = n.bit_length() - 1
def sum(self, i):
""" 区間[0,i) の総和を求める """
s = 0
i -= 1
... | p02599 |
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
"""
:param n: 最大の要素数
"""
self.n = n
self.tree = [0]*(n+1)
self.depth = n.bit_length() - 1
def sum(self, i):
""" 区間[0,i) の総和を求める """
s = 0
i -= 1
... | import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
"""
:param n: 最大の要素数
"""
self.n = n
self.tree = [0]*(n+2)
self.depth = n.bit_length() - 1
def sum(self, i):
""" 区間[0,i) の総和を求める """
s = 0
while i:
... | p02599 |
import sys
input = sys.stdin.readline
from collections import defaultdict
class BIT:
"""
Binary Index Tree
###1-origin####
add :L[i]+=x
sum: sum(L[:l])
range_sum : sum(L[l:r])
#material http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, N, init_val=0):
... | import sys
input = sys.stdin.readline
from collections import defaultdict
class BIT:
"""
Binary Index Tree
###1-origin####
add :L[i]+=x
sum: sum(L[:l])
range_sum : sum(L[l:r])
#material http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, N, init_val=0):
... | p02599 |
import sys
input = sys.stdin.readline
from collections import defaultdict
class BIT:
"""
Binary Index Tree
###1-origin####
add :L[i]+=x
sum: sum(L[:l])
range_sum : sum(L[l:r])
#material http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, N, init_val=0):
... | import sys
input = sys.stdin.readline
class BIT:
"""
Binary Index Tree
###1-origin####
add :L[i]+=x
sum: sum(L[:l])
range_sum : sum(L[l:r])
#material http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, N, init_val=0):
self.init_val = init_val
... | p02599 |
import sys
input = sys.stdin.readline
class SegmentTree:
def __init__(self, target, no_effect=0):
target_size = len(target)
leaves_size = 1
while leaves_size < target_size:
leaves_size *= 2
self.tree_size = leaves_size * 2 - 1
self.tree = [no_effect] ... | import sys
input = sys.stdin.readline
class SegmentTree:
def __init__(self, target, no_effect=set()):
target_size = len(target)
leaves_size = 1
while leaves_size < target_size:
leaves_size *= 2
self.tree_size = leaves_size * 2 - 1
self.tree = [no_effe... | p02599 |
import sys
input = sys.stdin.readline
class BIT:
def __init__(self, N):
self.N = N
self.bit = [0] * (N+1)
def add(self, x, a):
while x <= self.N:
self.bit[x] += a
x += x & -x
def sum(self, x):
ret = 0
while x != 0:
... | import sys
input = sys.stdin.readline
def add(x, a):
while x <= N:
bit[x] += a
x += x & -x
def sum(x):
ret = 0
while x != 0:
ret += bit[x]
x -= x & -x
return ret
N, Q = map(int, input().split())
bit = [0] * (N+1)
c = list(map(int, input().split()))
rl... | p02599 |
import sys
input = sys.stdin.readline
def main():
N, Q = list(map(int, input().split()))
bit = [0] * (N+1)
def add(x, a):
while x <= N:
bit[x] += a
x += x & -x
def sum(x):
ret = 0
while x != 0:
ret += bit[x]
x -= ... | import sys
input = sys.stdin.readline
def main():
N, Q = list(map(int, input().split()))
bit = [0] * (N+1)
def add(x, a):
while x <= N:
bit[x] += a
x += x & -x
def sum(x):
ret = 0
while x != 0:
ret += bit[x]
x -= ... | p02599 |
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0 for _ in range(n + 2)]
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
... | import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0 for _ in range(n + 2)]
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
... | p02599 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): retur... | #!/usr/bin/env python3
from collections import defaultdict
import sys
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
def LI(): return list(map(int, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def LIR(n):
res = [None] * n
fo... | p02599 |
from bisect import *
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
class BIT():
def __init__(self, n):
self.size = n
self.bit = [0] * (n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.... | from bisect import *
import sys
input = sys.stdin.readline
n, q = map(int, input().split())
c = list(map(int, input().split()))
class BIT():
def __init__(self, n):
self.size = n
self.bit = [0] * (n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]... | p02599 |
class BinaryIndexedTree(object):
def __init__(self, N):
self.N = N
self.bit = [0] * (N + 1)
def bit_add(self, index, num):
while (index <= self.N):
self.bit[index] += num
index += index & -index
return
def bit_sum(self,index):
res... | class BinaryIndexedTree(object):
def __init__(self, N):
self.N = N
self.bit = [0] * (N + 1)
def bit_add(self, index, num):
while (index <= self.N):
self.bit[index] += num
index += index & -index
return
def bit_sum(self,index):
res... | p02599 |
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
class SegmentTree(object):
def __init__(self, A, dot, unit):
n = 1 << (len(A) - 1).bit_length()
tree = [unit] * (2 * n)
for i, v in enumerate(A):
... | import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
class SegmentTree(object):
def __init__(self, A, dot, unit):
n = 1 << (len(A) - 1).bit_length()
tree = [unit] * (2 * n)
for i, v in enumerate(A):
... | p02599 |
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,in... | import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
d... | p02599 |
from typing import Union
from operator import itemgetter
Num = Union[int, float]
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 ... | from typing import Union
import sys
from operator import itemgetter
Num = Union[int, float]
class FenwickTree:
def __init__(self, size: int):
self.size = size
self.bit = [0] * (self.size + 1)
def add(self, k: int, x: Num) -> None:
"""
(0-index で) k 番目の要素に x ... | p02599 |
from typing import Union
import sys
from operator import itemgetter
Num = Union[int, float]
class FenwickTree:
def __init__(self, size: int):
self.size = size
self.bit = [0] * (self.size + 1)
def add(self, k: int, x: Num) -> None:
"""
(0-index で) k 番目の要素に x ... | from typing import Union
import sys
from operator import itemgetter
Num = Union[int, float]
class FenwickTree:
def __init__(self, size: int):
self.size = size
self.bit = [0] * (self.size + 1)
def add(self, k: int, x: Num) -> None:
"""
(0-index で) k 番目の要素に x ... | p02599 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools, bisect
import math, fractions
import sys, copy
def L(): return sys.stdin.... | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools, bisect
import math, fractions
import sys, copy
def L(): return sys.stdin.... | p02599 |
# From: https://github.com/cheran-senthil/PyRival/blob/master/pyrival/data_structures/SegmentTree.py
class SegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
... | import io
import os
from collections import Counter
from bisect import bisect_left, bisect_right
# From https://www.geeksforgeeks.org/mos-algorithm-query-square-root-decomposition-set-1-introduction/
def solve(C, LR):
order = sorted(list(range(len(LR))), key=lambda i: LR[i][1])
currL, currR = 0, ... | p02599 |
def main():
n,q=list(map(int,input().split()))
lst=[0]*n
clst=tuple(map(int,input().split()))
work={}
for i in range(n):
if clst[i] in work:
work[clst[i]]+=1
else :
work[clst[i]]=1
lst[i]=work.copy()
for _ in range(q):
l,r... | def main():
n,q=list(map(int,input().split()))
clst=tuple(map(int,input().split()))
for _ in range(q):
l,r=list(map(int,input().split()))
print((len(set(clst[l-1:r]))))
main() | p02599 |
def main():
import sys
input = sys.stdin.buffer.readline
def I(): return int(eval(input()))
readline = sys.stdin.readline
readall = sys.stdin.read
MI = lambda: list(map(int, readline().split()))
LI = lambda: list(map(int, readline().split()))
class BIT:
'''
... | def main():
import sys
input = sys.stdin.buffer.readline
def I(): return int(eval(input()))
readline = sys.stdin.readline
readall = sys.stdin.read
MI = lambda: list(map(int, readline().split()))
LI = lambda: list(map(int, readline().split()))
class BIT:
'''
... | p02599 |
def main():
import sys
input = sys.stdin.buffer.readline
def I(): return int(eval(input()))
readline = sys.stdin.readline
readall = sys.stdin.read
MI = lambda: list(map(int, readline().split()))
LI = lambda: list(map(int, readline().split()))
class BIT:
'''
... | def main():
import sys
input = sys.stdin.buffer.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
class BIT:
'''
0-indexed
'''
def __init__(self, N):
... | p02599 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | p02599 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | p02599 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | p02599 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | p02599 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
... | import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def LIR(row,col):
... | p02599 |
#!/usr/bin/env python3
MAX_VAL = 5 * 10 ** 5 + 1
class FenwickTree(object):
def __init__(self, num_elems):
self.num_elems = num_elems
self.data = [0 for _ in range(num_elems)]
def sum_to(self, end):
s = 0
i = end - 1
while i >= 0:
s += se... | #!/usr/bin/env pypy3
MAX_VAL = 5 * 10 ** 5 + 1
class FenwickTree(object):
def __init__(self, num_elems):
self.num_elems = num_elems
self.data = [0 for _ in range(num_elems)]
def sum_to(self, end):
s = 0
i = end - 1
while i >= 0:
s += self... | p02599 |
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
c = [int(i) for i in input().split()]
lr = [[int(i) for i in input().split()] for _ in range(Q)]
class SegTree:
def __init__(self, n) :
i = 1
while i < n :
i <<= 1
self.n = i
self.tree = [set() for _ in ... | import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
c = [int(i) for i in input().split()]
lr = [[int(i) - 1 for i in input().split()] for _ in range(Q)]
class BinaryIndexedTree() :
def __init__(self, n) :
self.n = n
self.tree = [0] * (n + 1)
def sum(self, i) :
... | p02599 |
#Mo
import sys
input = sys.stdin.readline
n,q=list(map(int, input().split()))
*c,=list(map(int, input().split()))
que=[]
for i in range(q):
li,ri=list(map(int, input().split()))
que.append((li-1,ri-1,i))
que.sort(key
=lambda x:(x[0]//1000,x[1]))
ll=0;rr=0
cnt=[0 for _ in range(500001)]
ans=... | import sys
input=sys.stdin.readline
n,q=list(map(int, input().split()))
*c,=list(map(int, input().split()))
qu=[list(map(int, input().split())) +[i] for i in range(q)]
qu.sort(key=lambda x:x[1])
bit=[0]*(n+1)
last=[-1]*(n+1)
def add(t,x):
while t<=n:
bit[t]+=x
t += t&(-t)
def que... | p02599 |
from operator import itemgetter
import sys
input = sys.stdin.readline
class BIT1():
"""
Binary Indexed Tree (1-indexed)
"""
def __init__(self, n):
self.n = n
self.bit = [0] * (self.n + 1)
self.data = [0] * (self.n + 1)
def add(self, idx, x):
# add x ... | from operator import itemgetter
import sys
input = sys.stdin.readline
class BIT1():
"""
Binary Indexed Tree (1-indexed)
"""
def __init__(self, n):
self.n = n
self.bit = [0] * (self.n + 1)
self.data = [0] * (self.n + 1)
def add(self, idx, x):
# add x ... | p02599 |
n, q = list(map(int, input().split()))
class SegmentTree:
def __init__(self, a, func=max, one=-10 ** 18):
self.logn = (len(a) - 1).bit_length()
self.n = 1 << self.logn
self.func = func
self.one = one
self.b = [self.one] * (2 * self.n - 1)
for i, j in enu... | class BIT:
def __init__(self, a, func=int.__add__, one=0):
self.n = len(a)
self.func = func
self.one = one
self.a = [0] * (self.n + 1)
for i, j in enumerate(a):
self.update(i, j)
def update(self, i, x):
i += 1
while i <= self.n:
... | p02599 |
#A1~Aiまでの和 O(logN) iが与えられたとき a1~aiまでの和を計算する(O(log n))
def BIT_query(BIT,idx):
res_sum=0
if idx==0:
return 0
while idx>0:
res_sum+=BIT[idx]
idx-=idx&(-idx)
return res_sum
#Ai+=x O(logN) iとxが与えられたとき ai+=x とする (O(log n))
def BIT_update(BIT,idx,x,n):
while idx<=n:
BIT[idx]+=x
id... | #A1~Aiまでの和 O(logN) iが与えられたとき a1~aiまでの和を計算する(O(log n))
def BIT_query(BIT,idx):
res_sum=0
if idx==0:
return 0
while idx>0:
res_sum+=BIT[idx]
idx-=idx&(-idx)
return res_sum
#Ai+=x O(logN) iとxが与えられたとき ai+=x とする (O(log n))
def BIT_update(BIT,idx,x,n):
while idx<=n:
BIT[idx]+=x
id... | p02599 |
def BIT_query(BIT,idx):
res_sum=0
if idx==0:
return 0
while idx>0:
res_sum+=BIT[idx]
idx-=idx&(-idx)
return res_sum
def BIT_update(BIT,idx,x,n):
while idx<=n:
BIT[idx]+=x
idx+=idx&(-idx)
return
def main():
N,Q=list(map( int, input().split()))
C=list( map( int, inpu... | def main():
N, Q = list(map( int, input().split()))
C = list( map( int, input().split()))
LRI = []
for i in range(Q):
l, r = list(map( int, input().split()))
LRI.append((r,l,i))
LRI.sort(key=lambda x:x[0])
lastAppend = [-1]*(N+1)
BIT = [0]*(N+1)
#A1 ~ Aiまでの和 O(l... | p02599 |
import sys
input = sys.stdin.readline
def BIT_query(BIT,idx):
res_sum=0
if idx==0:
return 0
while idx>0:
res_sum+=BIT[idx]
idx-=idx&(-idx)
return res_sum
def BIT_update(BIT,idx,x,n):
while idx<=n:
BIT[idx]+=x
idx+=idx&(-idx)
return
def main():
N,Q=list(map( int, i... | import sys
input = sys.stdin.readline
#A1~Aiまでの和 O(logN) iが与えられたとき a1~aiまでの和を計算する(O(log n))
def BIT_query(BIT,idx):
res_sum=0
if idx==0:
return 0
while idx>0:
res_sum+=BIT[idx]
idx-=idx&(-idx)
return res_sum
#Ai+=x O(logN) iとxが与えられたとき ai+=x とする (O(log n))
def BIT_update(BIT,idx,x,n):
... | p02599 |
import sys
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for... | import sys
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for... | p02599 |
import sys
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for... | import sys
from operator import itemgetter
def input(): return sys.stdin.buffer.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(... | p02599 |
import sys, math, bisect
if(__name__ == "__main__"):
N, Q = list(map(int, input().strip().split() ))
colors = list( map(int, input().strip().split() ) )
Num_colors_list= [ [0]*N for _ in range(N) ]
Queries = [ [0, 0] for _ in range(Q) ]
for i in range(Q):
l, r = list(map(i... | import sys, math, bisect
if(__name__ == "__main__"):
N, Q = list(map(int, input().strip().split() ))
colors = list( map(int, input().strip().split() ) )
Queries = [ [0, 0] for _ in range(Q) ]
for i in range(Q):
l, r = list(map(int, input().strip().split() ))
Queries[... | p02599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.