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_list) + 1
self.data = [self.e] + length_or_list
for i in range(1, self.n):
self.data[i + (i & -i)] = self.func(self.data[i + (i & -i)], self.data[i])
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] = self.func(self.data[index], delta)
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res = self.func(res, self.data[end])
end -= end & -end
return res
N, Q = map(int, input().split())
cs = list(map(int, input().split()))
lrs = [tuple(map(int, input().split())) for _ in range(Q)]
#クエリを終了位置rでソート。
ilrs = [(i, l-1, r-1) for i, (l, r) in enumerate(lrs)]
ilrs.sort(key = lambda t: t[2])
#重複を区間としてし、終了位置でソートされた状態で列挙。
duplicates = []
indices = [-1 for _ in range(N+1)]
for i, c in enumerate(cs):
if indices[c] != -1:
duplicates.append((indices[c], i))
indices[c] = i
#あとは平面走査と呼ばれる探査
ilrs.reverse()
duplicates.reverse()
starts = BIT(N, add, 0)
ans = [-1] * Q
for i in range(N):
if duplicates and duplicates[-1][1] == i:
dupstart, _ = duplicates.pop()
starts.point_append(dupstart, 1)
while ilrs[-1][2] == i:
ans_i, l, r = ilrs.pop()
ans[ans_i] = (r - l + 1) - (starts.prefix_folded(r + 1) - starts.prefix_folded(l))
if not ilrs:
break
else:
continue
break
print(*ans, sep = '\n')
| 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
else:
self.n = len(length_or_list) + 1
self.data = [self.e] + length_or_list
for i in range(1, self.n):
self.data[i + (i & -i)] = self.func(self.data[i + (i & -i)], self.data[i])
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] = self.func(self.data[index], delta)
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res = self.func(res, self.data[end])
end -= end & -end
return res
N, Q = map(int, input().split())
cs = list(map(int, input().split()))
lrs = [tuple(map(int, input().split())) for _ in range(Q)]
#クエリを終了位置rでソート。
ilrs = sorted(((i, l-1, r-1) for i, (l, r) in enumerate(lrs)), key = lambda t: t[2])
#重複を区間としてし、終了位置でソートされた状態で列挙。
duplicates = []
indices = [-1 for _ in range(N+1)]
for i, c in enumerate(cs):
if indices[c] != -1:
duplicates.append((indices[c], i))
indices[c] = i
#あとは平面走査と呼ばれる探査
ilrs.reverse()
duplicates.reverse()
starts = BIT(N, add, 0)
ans = [-1] * Q
for i in range(N):
if duplicates and duplicates[-1][1] == i:
dupstart, _ = duplicates.pop()
starts.point_append(dupstart, 1)
while ilrs[-1][2] == i:
ans_i, l, r = ilrs.pop()
ans[ans_i] = (r - l + 1) - (starts.prefix_folded(r + 1) - starts.prefix_folded(l))
if not ilrs:
break
else:
continue
break
print(*ans, sep = '\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 idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
def BIT_update(idx,x): # idxにxを足す
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
cn = max(Color)
Last = [-1] * cn
cnt = 0
for r, l, i in Query:
while cnt < r:
cnt += 1
c = Color[cnt] - 1
if Last[c] == -1:
Last[c] = cnt
BIT_update(cnt, 1)
else:
x = Last[c]
BIT_update(x, -1)
Last[c] = cnt
BIT_update(cnt, 1)
Ans[i] = BIT_query(r) - BIT_query(l-1)
for a in Ans:
print(a) | 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を使う
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 <= N:
BIT[idx] += x
idx += idx&(-idx)
return
cn = max(Color)
Last = [-1] * cn
cnt = 0
for q in Query:
r = q // 10 ** 12
l = (q % 10 ** 12) // 10 ** 6
i = q % 10 ** 6
while cnt < r:
cnt += 1
c = Color[cnt] - 1
if Last[c] == -1:
Last[c] = cnt
BIT_update(cnt, 1)
else:
x = Last[c]
BIT_update(x, -1)
Last[c] = cnt
BIT_update(cnt, 1)
Ans[i] = BIT_query(r) - BIT_query(l-1)
for a in Ans:
print(a) | 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
while index >= 1:
res += self.data[index]
index -= index & -index
return res
def get(self, left, right):
return self.sum(right) - self.sum(left-1)
def __getitem__(self, index):
return self.sum(index) - self.sum(index-1)
# def __setitem__(self, index, x):
# before = self.__getitem__(index)
# self.add(index, -before)
# self.add(index, x)
def main():
from sys import setrecursionlimit, stdin, stderr
from os import environ
from collections import defaultdict, deque, Counter
from math import ceil, floor
from itertools import accumulate, combinations, combinations_with_replacement
setrecursionlimit(10**6)
dbg = (lambda *something: stderr.write("\033[92m{}\033[0m".format(str(something)+'\n'))) if 'TERM_PROGRAM' in environ else lambda *x: 0
input = lambda: stdin.readline().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(eval(input()))
P = 10**9+7
INF = 10**18+10
N,Q = LMIIS()
# 1-indexedにするためリストの先頭に0を追加
C = [0] + LMIIS()
queries = []
# 順番と一緒にクエリを保存
for i in range(Q):
queries.append((i,LMIIS()))
# rについてクエリをソート
queries.sort(key=lambda x: x[1][1])
# 玉の種類 -> 良い玉の場所
good_ball_places = [0] * (N+1)
# 場所 -> 良い玉が存在するなら1,しないなら0
good_ball_exists = BinaryIndexedTree()
# 玉の更新範囲は[0:k]
k = 1
# クエリの回答
out = [0] * Q
for j,(l,r) in queries:
for i in range(k,r+1):
# 位置iの玉の色
color = C[i]
# 色colorの良い玉の前の位置
before = good_ball_places[color]
# 色colorが既出なら、良い玉の場所をリセット
if before != 0:
good_ball_exists.add(before,-1)
# 色colorの良い玉の位置はi
good_ball_places[color] = i
# 位置iに良い玉が存在
good_ball_exists.add(i,1)
out[j] = good_ball_exists.get(l,r)
print(('\n'.join(map(str,out))))
main() | 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
while index >= 1:
res += self.data[index]
index -= index & -index
return res
def interval_sum(self, left, right):
return self.prefix_sum(right) - self.prefix_sum(left-1)
def __getitem__(self, index):
return self.sum(index) - self.sum(index-1)
# def __setitem__(self, index, x):
# before = self.__getitem__(index)
# self.add(index, -before)
# self.add(index, x)
def main():
from sys import stdin
input = lambda: stdin.readline()
LMIIS = lambda: list(map(int,input().split()))
N,Q = LMIIS()
# 1-indexedにするためリストの先頭に0を追加
C = [0] + LMIIS()
queries = []
# 順番と一緒にクエリを保存
for i in range(Q):
l,r = list(map(int,input().split()))
queries.append((i,l,r))
# rについてクエリをソート
queries.sort(key=lambda x: x[2])
# 玉の種類 -> 良い玉の場所
good_ball_places = [0] * (N+1)
# 場所 -> 良い玉が存在するなら1,しないなら0
good_ball_exists = BinaryIndexedTree()
# 玉の更新済み範囲
k = 0
# クエリの回答
out = [0] * Q
for order,l,r in queries:
for i in range(k+1,r+1):
# 位置iの玉の色
color = C[i]
# 色colorの良い玉の前の位置
before = good_ball_places[color]
# 色colorが既出なら、前の位置での存在を消去
if 0 < before:
good_ball_exists.add(before,-1)
# 色colorの良い玉の位置はi
good_ball_places[color] = i
# 位置iに良い玉が存在
good_ball_exists.add(i,1)
# 良い玉を更新した範囲
k = r
# [l,r]に存在する良い玉の数の合計
out[order] = good_ball_exists.interval_sum(l,r)
print(('\n'.join(map(str,out))))
main() | 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
while index >= 1:
res += self.data[index]
index -= index & -index
return res
def interval_sum(self, left, right):
return self.prefix_sum(right) - self.prefix_sum(left-1)
def __getitem__(self, index):
return self.sum(index) - self.sum(index-1)
# def __setitem__(self, index, x):
# before = self.__getitem__(index)
# self.add(index, -before)
# self.add(index, x)
def main():
from sys import stdin
input = lambda: stdin.readline()
LMIIS = lambda: list(map(int,input().split()))
N,Q = LMIIS()
# 1-indexedにするためリストの先頭に0を追加
C = [0] + LMIIS()
queries = []
# 順番と一緒にクエリを保存
for i in range(Q):
l,r = list(map(int,input().split()))
queries.append((i,l,r))
# rについてクエリをソート
queries.sort(key=lambda x: x[2])
# 玉の種類 -> 良い玉の場所
good_ball_places = [0] * (N+1)
# 場所 -> 良い玉が存在するなら1,しないなら0
good_ball_exists = BinaryIndexedTree(N)
# 玉の更新済み範囲
k = 0
# クエリの回答
out = [0] * Q
for order,l,r in queries:
for i in range(k+1,r+1):
# 位置iの玉の色
color = C[i]
# 色colorの良い玉の前の位置
before = good_ball_places[color]
# 色colorが既出なら、前の位置での存在を消去
if 0 < before:
good_ball_exists.add(before,-1)
# 色colorの良い玉の位置はi
good_ball_places[color] = i
# 位置iに良い玉が存在
good_ball_exists.add(i,1)
# 良い玉を更新した範囲
k = r
# [l,r]に存在する良い玉の数の合計
out[order] = good_ball_exists.interval_sum(l,r)
print(('\n'.join(map(str,out))))
main() | 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
while index >= 1:
res += self.data[index]
index -= index & -index
return res
def interval_sum(self, left, right):
return self.prefix_sum(right) - self.prefix_sum(left-1)
def __getitem__(self, index):
return self.sum(index) - self.sum(index-1)
# def __setitem__(self, index, x):
# before = self.__getitem__(index)
# self.add(index, -before)
# self.add(index, x)
def main():
from sys import stdin
input = lambda: stdin.readline()
LMIIS = lambda: list(map(int,input().split()))
N,Q = LMIIS()
# 1-indexedにするためリストの先頭に0を追加
C = [0] + LMIIS()
# クエリを保存するリストのリスト, r -> (l,クエリの順番)のリスト
queries = []
for i in range(N+1):
queries.append([])
# クエリを保存
for i in range(Q):
l,r = list(map(int,input().split()))
queries[r].append((l,i))
# 玉の種類 -> 良い玉の場所
good_ball_places = [0] * (N+1)
# 場所 -> 良い玉が存在するなら1,しないなら0
good_ball_exists = BinaryIndexedTree(N)
# 玉の更新済み範囲
k = 0
# クエリの回答
out = [0] * Q
for r,query in enumerate(queries):
for l,order in query:
for i in range(k+1,r+1):
# 位置iの玉の色
color = C[i]
# 色colorの良い玉の前の位置
before = good_ball_places[color]
# 色colorが既出なら、前の位置での存在を消去
if 0 < before:
good_ball_exists.add(before,-1)
# 色colorの良い玉の位置はi
good_ball_places[color] = i
# 位置iに良い玉が存在
good_ball_exists.add(i,1)
# 良い玉を更新した範囲
k = r
# [l,r]に存在する良い玉の数の合計
out[order] = good_ball_exists.interval_sum(l,r)
print(('\n'.join(map(str,out))))
main() | 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:
bit[idx] += val
idx += idx & -idx
# querying the bit array
def query(idx, bit, n):
summ = 0
while idx:
summ += bit[idx]
idx -= idx & -idx
return summ
def answeringQueries(arr, n, queries, q):
# initialising bit array
bit = [0] * (n + 1)
# holds the rightmost index of
# any number as numbers of a[i]
# are less than or equal to 10^6
last_visit = [-1] * MAX
# answer for each query
ans = [0] * q
query_counter = 0
for i in range(n):
# If last visit is not -1 update -1 at the
# idx equal to last_visit[arr[i]]
if last_visit[arr[i]] != -1:
update(last_visit[arr[i]] + 1, -1, bit, n)
# Setting last_visit[arr[i]] as i and
# updating the bit array accordingly
last_visit[arr[i]] = i
update(i + 1, 1, bit, n)
# If i is equal to r of any query store answer
# for that query in ans[]
while query_counter < q and queries[query_counter].r == i:
ans[queries[query_counter].idx] = query(queries[query_counter].r + 1, bit, n) - query(queries[query_counter].l, bit, n)
query_counter += 1
# print answer for each query
for i in range(q):
print((ans[i]))
# Driver Code
n,q=list(map(int,input().split()))
a=list(map(int,input().split()))
queries=[]
for i in range(q):
c,d=list(map(int,input().split()))
queries.append(Query(c-1,d-1,i))
queries.sort(key = lambda x: x.r)
answeringQueries(a, n, queries, q) | 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
# updating the bit array
def update(idx, val, bit, n):
while idx <= n:
bit[idx] += val
idx += idx & -idx
# querying the bit array
def query(idx, bit, n):
summ = 0
while idx:
summ += bit[idx]
idx -= idx & -idx
return summ
def answeringQueries(arr, n, queries, q):
# initialising bit array
bit = [0] * (n + 1)
# holds the rightmost index of
# any number as numbers of a[i]
# are less than or equal to 10^6
last_visit = [-1] * MAX
# answer for each query
ans = [0] * q
query_counter = 0
for i in range(n):
# If last visit is not -1 update -1 at the
# idx equal to last_visit[arr[i]]
if last_visit[arr[i]] != -1:
update(last_visit[arr[i]] + 1, -1, bit, n)
# Setting last_visit[arr[i]] as i and
# updating the bit array accordingly
last_visit[arr[i]] = i
update(i + 1, 1, bit, n)
# If i is equal to r of any query store answer
# for that query in ans[]
while query_counter < q and queries[query_counter].r == i:
ans[queries[query_counter].idx] = query(queries[query_counter].r + 1, bit, n) - query(queries[query_counter].l, bit, n)
query_counter += 1
# print answer for each query
for i in range(q):
print((ans[i]))
# Driver Code
n,q=list(map(int,input().split()))
a=list(map(int,input().split()))
queries=[]
for i in range(q):
c,d=list(map(int,input().split()))
queries.append(Query(c-1,d-1,i))
queries.sort(key = lambda x: x.r)
answeringQueries(a, n, queries, q) | 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):
s = 0
while i>0:
s += self.bit[i]
i -= i&(-i)
return s
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
prev = [-1]*N
ys = defaultdict(list)
for i in range(N):
if prev[c[i]-1]!=-1:
ys[prev[c[i]-1]].append(i)
prev[c[i]-1] = i
lr = [(i,)+tuple(map(int, input().split())) for i in range(Q)]
lr.sort(key=lambda t: t[1], reverse=True)
idx = 0
bit = BIT(N)
ans = []
for x in range(N-1, -1, -1):
for y in ys[x]:
bit.add(y, 1)
while idx<Q and lr[idx][1]-1==x:
i, l, r = lr[idx][0], lr[idx][1]-1, lr[idx][2]-1
ans.append((i, r-l+1-bit.acc(r+1)))
idx += 1
ans.sort(key=lambda t: t[0])
for ans_i in ans:
print((ans_i[1])) | 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):
s = 0
while i>0:
s += self.bit[i]
i -= i&(-i)
return s
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
prev = [-1]*N
ys = defaultdict(list)
for i in range(N):
if prev[c[i]-1]!=-1:
ys[prev[c[i]-1]].append(i)
prev[c[i]-1] = i
que = defaultdict(list)
for i in range(Q):
l, r = list(map(int, input().split()))
que[l-1].append((i, r-1))
idx = 0
bit = BIT(N)
ans = []
for x in range(N-1, -1, -1):
for y in ys[x]:
bit.add(y, 1)
for i, r in que[x]:
ans.append((i, r-x+1-bit.acc(r+1)))
ans.sort(key=lambda t: t[0])
for ans_i in ans:
print((ans_i[1])) | 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):
s = 0
while i>0:
s += self.bit[i]
i -= i&(-i)
return s
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
prev = [-1]*N
ys = defaultdict(list)
for i in range(N):
if prev[c[i]-1]!=-1:
ys[prev[c[i]-1]].append(i)
prev[c[i]-1] = i
que = defaultdict(list)
for i in range(Q):
l, r = list(map(int, input().split()))
que[l-1].append((i, r-1))
idx = 0
bit = BIT(N)
ans = []
for x in range(N-1, -1, -1):
for y in ys[x]:
bit.add(y, 1)
for i, r in que[x]:
ans.append((i, r-x+1-bit.acc(r+1)))
ans.sort(key=lambda t: t[0])
for ans_i in ans:
print((ans_i[1])) | 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):
s = 0
while i>0:
s += self.bit[i]
i -= i&(-i)
return s
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
prev = [-1]*N
ys = defaultdict(list)
for i in range(N):
if prev[c[i]-1]!=-1:
ys[prev[c[i]-1]].append(i)
prev[c[i]-1] = i
que = defaultdict(list)
for i in range(Q):
l, r = list(map(int, input().split()))
que[l-1].append((i, r-1))
idx = 0
bit = BIT(N)
ans = [-1]*Q
for x in range(N-1, -1, -1):
for y in ys[x]:
bit.add(y, 1)
for i, r in que[x]:
ans[i] = r-x+1-bit.acc(r+1)
for ans_i in ans:
print(ans_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]."""
res = 0
while i > 0:
res += self.bit[i]
i -= i & -i
return res
def query(self, i, j):
"""Sum a[i]~a[j]."""
return self.sumup(j) - self.sumup(i - 1)
N, Q = map(int, input().split())
C = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(Q)]
ans = [0] * Q
last_appeared = [0] * (N + 1)
bit = BIT(N + 1)
rm = 0
for i, (l, r) in sorted(enumerate(X), key=lambda x: x[1][1]):
for j in range(rm + 1, r + 1):
if last_appeared[C[j - 1]] > 0:
bit.add(last_appeared[C[j - 1]], -1)
last_appeared[C[j - 1]] = j
bit.add(j, 1)
rm = r
ans[i] = bit.query(l, r)
print(*ans, sep="\n")
|
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]
res = 0
while i > 0:
res += self.bit[i]
i -= i & -i
return res
def query(self, i, j):
# Sum a[i]~a[j]
return self.sumup(j) - self.sumup(i - 1)
N, Q = map(int, input().split())
C = list(map(int, input().split()))
X = []
for i in range(Q):
l, r = map(int, input().split())
X.append((i, l, r))
X.sort(key=lambda x: x[2])
ans = [0] * Q
bit = BIT(N + 1)
last = [0] * (N + 1)
k = 0
for i, l, r in X:
for j in range(k + 1, r + 1):
if last[C[j - 1]] > 0:
bit.add(last[C[j - 1]], -1)
bit.add(j, 1)
last[C[j - 1]] = j
k = r
ans[i] = bit.query(l, r)
print(*ans, sep="\n")
| 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()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class SegmentTree:
def __init__(self, S):
N = len(S)
d = N.bit_length()
T = [0 for _ in range(2 ** (d + 1) - 1)]
for i, s in enumerate(S):
T[i + 2 ** d - 1] = 1 << s
for i in range(2 ** d - 2, -1, -1):
T[i] = T[2 * i + 1] | T[2 * i + 2]
self.d = d
self.T = T
def update(self, i, a):
i = i + 2 ** self.d - 1
while i > 0:
i = (i - 1) // 2
self.T[i] = self.T[2 * i + 1] | self.T[2 * i + 2]
def query(self, a, b):
return self._query(a, b, 0, 0, 2 ** self.d)
def _query(self, a, b, k, l, r):
if r <= a or b <= l:
return 0
if a <= l and r <= b:
return self.T[k]
else:
s1 = self._query(a, b, 2 * k + 1, l, (l + r) // 2)
s2 = self._query(a, b, 2 * k + 2, (l + r) // 2, r)
return s1 | s2
def main():
N, Q = read_values()
C = read_list()
ST = SegmentTree(C)
for _ in range(Q):
a, b = read_index()
print((format(ST.query(a, b + 1), "b").count("1")))
if __name__ == "__main__":
main()
| 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()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class BIT:
def __init__(self, N):
self.N = N
self.T = [0] * (N + 1)
def add(self, i, x):
i += 1
while i <= self.N:
self.T[i] += x
i += i & -i
def _sum(self, i):
s = 0
i += 1
while i > 0:
s += self.T[i]
i -= i & -i
return s
def sum(self, i, j):
si = self._sum(i - 1)
sj = self._sum(j)
return sj - si
def main():
N, M = read_values()
C = read_list()
Q = []
for i in range(M):
l, r = read_index()
Q.append((l, r, i))
Q.sort(key=lambda a: a[1])
ans = [0] * M
T = [-1] * M
bit = BIT(N)
q = 0
# print(Q)
for i in range(N):
c = C[i] - 1
t = T[c]
if t != -1:
bit.add(t, -1)
T[c] = i
bit.add(i, 1)
# print(i, T, bit.T)
while q < len(Q) and i == Q[q][1]:
l, r, k = Q[q]
ans[k] = bit.sum(l, r)
q += 1
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| 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.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
for i in range(q):
l, r = list(map(int, input().split()))
qry[i] = [l-1, r, i]
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
for i in range(q):
l, r = list(map(int, input().split()))
qry[i] = [l-1, r, i]
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
for i in range(q):
l, r = list(map(int, input().split()))
qry[i] = [l-1, r, i]
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
segupd = seg.update
segqry = seg.query
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
segupd(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
segupd(dic[v], 1)
last_update_idx = r
ans[i] = segqry(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in range(q):
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in range(q):
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j, col in enumerate(color[last_update_idx: r]):
if not col in st and col in dic:
seg.update(dic[col], 0)
dic[col] = j+last_update_idx
st.add(col)
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in range(q):
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if color[j] in dic and not color[j] in st:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
self.dic = {}
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
if (p, q) in self.dic:
return self.dic[(p, q)]
else:
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
self.dic[(p, q)] = res
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in range(q):
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in range(q):
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
segupd = seg.update
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
segupd(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
segupd(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in range(q):
l, r = list(map(int, input().split()))
qry[p] = (l-1, r, p)
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in ans:
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
def main():
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [None]*q
p = 0
for _ in ans:
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
if __name__ == "__main__":
main()
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [0]*q
p = 0
for _ in ans:
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
| 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):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):#p <= x < q
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
n, q = list(map(int, input().split()))
color = list(map(int, input().split()))
qry = [None]*q
ans = [0]*q
p = 0
for _ in ans:
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 0
seg = SegTree(0, n, [0]*n)
for l, r, i in qry:
if last_update_idx < r:
st = set()
for j in range(last_update_idx, r):
if not color[j] in st and color[j] in dic:
seg.update(dic[color[j]], 0)
dic[color[j]] = j
st.add(color[j])
for v in st:
seg.update(dic[v], 1)
last_update_idx = r
ans[i] = seg.query(l, r)
for v in ans:
print(v)
| 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):
while i <= self.size:
self.tree[i] += x
i += i & -i
n, q = list(map(int, input().split()))
tmp = list(map(int, input().split()))
color = [-1]
for v in tmp:
color.append(v)
qry = [None]*q
ans = [0]*q
p = 0
for _ in ans:
l, r = list(map(int, input().split()))
qry[p] = [l-1, r, p]
p += 1
qry.sort(key=lambda x: x[1])
dic = {}
last_update_idx = 1
bit = Bit(n)
for l, r, i in qry:
if last_update_idx < r+1:
st = set()
for j in range(last_update_idx, r+1):
if not color[j] in st and color[j] in dic:
bit.add(dic[color[j]], -1)
dic[color[j]] = j
st.add(color[j])
for v in st:
bit.add(dic[v], 1)
last_update_idx = r+1
ans[i] = bit.sum(r) - bit.sum(l)
for v in ans:
print(v)
| 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):
while idx <= self.n:
self.tree[idx] += x
idx += idx & -idx
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 range(N)]
res = [0 for _ in range(Q)]
bit = BinaryIndexedTree(N)
for l, r, id in query:
while rt < r:
if L[C[rt]] is not None:
bit.add(L[C[rt]] + 1, -1)
L[C[rt]] = rt
bit.add(rt + 1, 1)
rt += 1
res[id] = bit.sum(r) - bit.sum(l)
print(('\n'.join(map(str, res)))) | 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 range(N)]
res = [0 for _ in range(Q)]
bit = [0 for _ in range(N + 1)]
for l, r, id in query:
while rt < r:
if L[C[rt]] is not None:
idx = L[C[rt]] + 1
while idx <= N:
bit[idx] -= 1
idx += idx & -idx
L[C[rt]] = rt
idx = rt + 1
while idx <= N:
bit[idx] += 1
idx += idx & -idx
rt += 1
sr = 0
sl = 0
idx = r
while idx:
sr += bit[idx]
idx -= idx & -idx
idx = l
while idx:
sl += bit[idx]
idx -= idx & -idx
res[id] = sr - sl
print(('\n'.join(map(str, res)))) | 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 __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N)
X = [-1] * (MAX_A + 1)
for i, a in enumerate(A, start=1):
X[a] = i
for x in X:
if x == -1:
continue
BIT.add(x, 1)
ans = [-1] * Q
query.sort(key=lambda x: x[1])
for l, r, i in query:
BIT.add(X[A[r - 1]], -1)
X[A[r - 1]] = r
BIT.add(r, 1)
ans[i] = BIT.sum(r) - BIT.sum(l - 1)
print(*ans, sep='\n')
| 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 BinaryIndexedTree:
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]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N)
X = [-1] * (MAX_A + 1)
for i, a in enumerate(A, start=1):
X[a] = i
for x in X:
if x == -1:
continue
BIT.add(x, 1)
ans = [-1] * Q
query.sort(key=lambda x: x[1])
mr = 0
for l, r, i in query:
while mr < r:
mr += 1
BIT.add(X[A[mr - 1]], -1)
X[A[mr - 1]] = mr
BIT.add(mr, 1)
ans[i] = BIT.sum(r) - BIT.sum(l - 1)
for a in ans:
print(a)
if __name__ == '__main__':
main()
| 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を加える
2. 区間和 ai + a(i+1) + ... + aj の和を求める
isom法を使えば、
1. aiの値を取得する
2. 区間[i, j]の全ての数にxを加算する
もO(logN)で行うことができる
"""
def __init__(self, n):
"""
添字は1スタート
"""
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def add(self, i, x):
"""
i>0に対してaiにxを加算(x < 0でもOK)
"""
if i <= 0 or self.n < i:
raise ValueError("i should be within 1 to n")
else:
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def sum(self, i):
"""
添字1からiまでの累積和を求める
"""
s = 0
while i > 0:
s += self.data[i]
i -= i & -i # i $ (-i)でiの最下位ビットのみ立った値を得る
return s
def get(self, i, j=None):
"""
添字iからjまでの累積和を求める
j=Noneの場合はaiの値を返す
"""
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i - 1)
def main():
"""
区間の種類数を答える問題は典型みたい。
https://hama-du-competitive.hatenablog.com/entry/2016/10/01/001418
ポイントはクエリをrの昇順に整理しておくこと。
玉の各種類ごとに、それが最後にどこで出現したかをBITに記録していく。
"""
N, Q = list(map(int, input().split()))
C = [0] + list(map(int, input().split()))
queri = []
for q in range(Q):
l, r = list(map(int, input().split()))
queri.append((r, l, q))
queri.sort()
# print("queri={}".format(queri))
lastAppeared = [0] * (N + 1) # lastAppeared[x] : 値 x が最後に出現した位置
r0, l0, _ = queri[0]
for i, c in enumerate(C):
if i == 0: continue
if i > r0: break
lastAppeared[c] = i
tree = BIT(N)
for x in range(1, N + 1):
if lastAppeared[x] != 0:
tree.add(lastAppeared[x], 1)
ans = [0] * Q
pre_R = r0
for r, l, q in queri:
if r > pre_R:
for i in range(pre_R + 1, r + 1):
if lastAppeared[C[i]] != 0:
tree.add(lastAppeared[C[i]], -1)
lastAppeared[C[i]] = i
tree.add(i, 1)
ans[q] = tree.get(l, r)
pre_R = r
# print("q={}, lastAppeared={}, ans={}".format(q, lastAppeared, ans[q]))
for a in ans: print(a)
if __name__ == "__main__":
main()
| 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を加える
2. 区間和 ai + a(i+1) + ... + aj の和を求める
isom法を使えば、
1. aiの値を取得する
2. 区間[i, j]の全ての数にxを加算する
もO(logN)で行うことができる
"""
def __init__(self, n):
"""
添字は1スタート
"""
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def add(self, i, x):
"""
i>0に対してaiにxを加算(x < 0でもOK)
"""
if i <= 0 or self.n < i:
raise ValueError("i should be within 1 to n")
else:
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def sum(self, i):
"""
添字1からiまでの累積和を求める
"""
s = 0
while i > 0:
s += self.data[i]
i -= i & -i # i $ (-i)でiの最下位ビットのみ立った値を得る
return s
def get(self, i, j=None):
"""
添字iからjまでの累積和を求める
j=Noneの場合はaiの値を返す
"""
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i - 1)
def main():
"""
区間の種類数を答える問題は典型みたい。
https://hama-du-competitive.hatenablog.com/entry/2016/10/01/001418
ポイントはクエリをrの昇順に整理しておくこと。
玉の各種類ごとに、それが最後にどこで出現したかをBITに記録していく。
"""
N, Q = list(map(int, input().split()))
C = [0] + list(map(int, input().split()))
queri = []
for q in range(Q):
l, r = list(map(int, input().split()))
queri.append(r * 10**12 + l * 10**6 + q)
queri.sort()
# print("queri={}".format(queri))
lastAppeared = [0] * (N + 1) # lastAppeared[x] : 値 x が最後に出現した位置
r0 = queri[0] // 10**12
for i, c in enumerate(C):
if i == 0: continue
if i > r0: break
lastAppeared[c] = i
tree = BIT(N)
for x in range(1, N + 1):
if lastAppeared[x] != 0:
tree.add(lastAppeared[x], 1)
ans = [0] * Q
pre_R = r0
for x in queri:
r, x = x // 10**12, x % 10**12
l, q = x // 10**6, x % 10**6
if r > pre_R:
for i in range(pre_R + 1, r + 1):
if lastAppeared[C[i]] != 0:
tree.add(lastAppeared[C[i]], -1)
lastAppeared[C[i]] = i
tree.add(i, 1)
ans[q] = tree.get(l, r)
pre_R = r
# print("q={}, lastAppeared={}, ans={}".format(q, lastAppeared, ans[q]))
for a in ans: print(a)
if __name__ == "__main__":
main()
| 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 + y
#################
#####ide_ele#####
ide_ele = 0
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
BIT = SegTree(bit, segfunc, ide_ele)
lastAppeared = [-1 for _ in range(n)]
ans = [None for _ in range(q)]
for i in range(n):
if lastAppeared[c[i]] != -1:
BIT.update(lastAppeared[c[i]], 0)
lastAppeared[c[i]] = i
BIT.update(i, 1)
while len(que) > 0 and que[0][0] == i:
r, l, x = heapq.heappop(que)
ans[x] = BIT.query(l, r+1)
if len(que) == 0:
break
print(*ans, sep='\n')
| 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)
self.num = n
def sum(self, i):
s = 0
while i > 0:
s += self.BIT[i]
i -= i & (-i)
return s
def add(self, i, x):
while i <= self.num:
self.BIT[i] += x
i += i & (-i)
que.sort(key=lambda x: -x[1])
ans = [None] * q
last = [-1] * n
BIT = SegTree(n)
for i in range(1, n+1):
if last[c[i-1]] != -1:
BIT.add(last[c[i-1]], -1)
last[c[i-1]] = i
BIT.add(i, 1)
while que and que[-1][1] == i:
l, r, x = que.pop()
ans[x] = BIT.sum(r) - BIT.sum(l-1)
print(*ans, sep='\n')
| 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 & -i
return s
def add(self, i, x):
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)
def lowerbound(self, s):
x = 0
y = 0
for i in range(self.n.bit_length(), -1, -1):
k = x + (1 << i)
if k <= self.n and (y + self.data[k] < s):
y += self.data[k]
x += 1 << i
return x + 1
qs = []
for i in range(Q):
l, r = list(map(int, input().split()))
qs.append((l, r, i))
qs.sort(key = lambda x: x[1])
last = [0] * (N + 1)
fwk = BIT(N)
for i in range(qs[0][1]): last[a[i]] = max(last[a[i]], i + 1)
for x in last:
if x: fwk.add(x, 1)
#print(last)
res = [0] * Q
rlast = qs[0][1]
for l, r, i in qs:
#print(l, r)
if rlast == r:
res[i] = fwk.get(l - 1, r)
else:
for x in range(rlast, r):
if last[a[x]]: fwk.add(last[a[x]], -1)
fwk.add(x + 1, 1)
last[a[x]] = x + 1
rlast = r
res[i] = fwk.get(l - 1, r)
for r in res: print(r) | 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 - 1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
#set_val
for i in range(n):
self.seg[i + self.num - 1] = init_val[i]
#built
for i in range(self.num - 2, -1, -1) :
self.seg[i] = self.segfunc(self.seg[2 * i + 1], self.seg[2 * i + 2])
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k + 1:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, p, q):
if q <= p:
return self.ide_ele
p += self.num - 1
q += self.num - 2
res = self.ide_ele
while q - p > 1:
if p & 1 == 0:
res = self.segfunc(res, self.seg[p])
if q & 1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
qs = []
for i in range(Q):
l, r = list(map(int, input().split()))
qs.append((l, r, i))
qs.sort(key = lambda x: x[1])
last = [0] * (N + 1)
fwk = SegTree(N + 1, 0, last)
for i in range(qs[0][1]): last[a[i]] = i + 1
for x in last:
if x: fwk.update(x, fwk.query(x, x + 1) + 1)
#print(last)
res = [0] * Q
rlast = qs[0][1]
for l, r, i in qs:
#print(l, r)
if rlast == r:
res[i] = fwk.query(l, r + 1)
else:
for x in range(rlast, r):
if last[a[x]]: fwk.update(last[a[x]], fwk.query(last[a[x]], last[a[x]] + 1) - 1)
fwk.update(x + 1, fwk.query(x + 1, x + 2) + 1)
last[a[x]] = x + 1
rlast = r
res[i] = fwk.query(l, r + 1)
for r in res: print(r) | 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-=(idx&-idx)
return ret
def sum(self,l,r):
return self._sum(r)-self._sum(l-1)
def value(self,i):
return self._sum(i)-self._sum(i-1)
n,q=list(map(int,input().split()))
arr=list(map(int,input().split()))
query=[]
for i in range(q):
l,r=list(map(int,input().split()))
query.append((l,r,i))
query=sorted(query,key=lambda x:x[0])
ans=[0]*q
bit=BIT(n)
pos_now=[-1]*(n+1)
pos_all=[[] for _ in range(n+1)]
for i in range(n):
val=arr[i]
if pos_now[val]==-1:
bit.add(i+1,1)
pos_now[val]=0
pos_all[val].append(i+1)
for i in range(n+1):
pos_all[i].append(-1)
prev=1
for l,r,id in query:
while prev<l:
val=arr[prev-1]
if pos_all[val][pos_now[val]+1]!=-1:
pos_now[val]+=1
bit.add(pos_all[val][pos_now[val]],1)
prev+=1
ans[id]=bit.sum(l,r)
for val in ans:
print(val) | 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-=(idx&-idx)
return ret
def sum(self,l,r):
return self._sum(r)-self._sum(l-1)
def value(self,i):
return self._sum(i)-self._sum(i-1)
n,q=list(map(int,input().split()))
arr=list(map(int,input().split()))
query=[]
for i in range(q):
l,r=list(map(int,input().split()))
query.append((l,r,i))
query=sorted(query,key=lambda x:x[0])
ans=[0]*q
bit=BIT(n)
pos_now=[-1]*(n+1)
pos_prev=[-1]*(n+1)
dic={}
for i in range(n):
val=arr[i]
dic[i+1]=-1
if pos_now[val]==-1:
bit.add(i+1,1)
pos_now[val]=i+1
if pos_prev[val]!=-1:
dic[pos_prev[val]]=i+1
pos_prev[val]=i+1
prev=1
for l,r,id in query:
while prev<l:
val=arr[prev-1]
if dic[pos_now[val]]!=-1:
pos_now[val]=dic[pos_now[val]]
bit.add(pos_now[val],1)
prev+=1
ans[id]=bit.sum(l,r)
for val in ans:
print(val) | 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 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
def main():
N, Q = in_nn()
C = in_nl()
LR = []
for q in range(Q):
l, r = in_nn()
LR.append((r + 0.1, l, q))
t = [-1] * (N + 1)
sect = []
for i in range(N):
x = C[i]
if t[x] != -1:
sect.append((i + 1, t[x], -1))
t[x] = i + 1
sect += LR
sect.sort()
bit = [0] * (N + 1)
def add(i, val):
while i <= N:
bit[i] += val
i += i & -i
def sum(i):
res = 0
while i > 0:
res += bit[i]
i -= i & -i
return res
ans = [0] * Q
for s in sect:
r, l, n = s
r = int(r)
if n == -1:
add(l, 1)
else:
t = sum(r) - sum(l - 1)
ans[n] = r - l + 1 - t
print(('\n'.join(map(str, ans))))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
def main():
N, Q = in_nn()
C = in_nl()
LR = []
for q in range(Q):
l, r = in_nn()
LR.append((r + 0.1, l, q))
t = [-1] * (N + 1)
sect = []
for i in range(N):
x = C[i]
if t[x] != -1:
sect.append((i + 1, t[x], -1))
t[x] = i + 1
sect += LR
sort_index = sorted(list(range(len(sect))), key=lambda i: sect[i][0])
bit = [0] * (N + 1)
def add(i, val):
while i <= N:
bit[i] += val
i += i & -i
def sum(i):
res = 0
while i > 0:
res += bit[i]
i -= i & -i
return res
ans = [0] * Q
for i in sort_index:
r, l, n = sect[i]
r = int(r)
if n == -1:
add(l, 1)
else:
t = sum(r) - sum(l - 1)
ans[n] = r - l + 1 - t
print(('\n'.join(map(str, ans))))
if __name__ == '__main__':
main()
| 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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def main():
n,q = list(map(int,ipt().split()))
# n = 5*10**5
# q = 5*10**5
# c = [int(i+1) for i in range(n)]
c = [2**(int(i)-1) for i in ipt().split()]
def segfunc(x,y):
return x|y
def popcnt(n):
return bin(n).count("1")
ST = SegTree(c,segfunc,0)
for i in range(q):
# l = 2; r = 5*10**5-1
l,r = list(map(int,ipt().split()))
print((popcnt(ST.query(l-1,r))))
return None
if __name__ == '__main__':
main()
| '''
自宅用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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n,q = list(map(int,ipt().split()))
# n = 5*10**5
# q = 5*10**5
# c = [int(i)+1 for i in range(n)]
c = [int(i) for i in ipt().split()]
qi = []
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append((r,l,i))
qi.sort()
ans = [-1]*q
ln = [-1]*(n+1)
#Bit_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
pr = 0
for r,l,i in qi:
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
ans[i] = BIT_query(r)-BIT_query(l-1)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| 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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n,q = list(map(int,ipt().split()))
# n = 5*10**5
# q = 5*10**5
# c = [int(i)+1 for i in range(n)]
c = [int(i) for i in ipt().split()]
qi = []
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append((r,l,i))
qi.sort()
ans = [-1]*q
ln = [-1]*(n+1)
#Bit_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
pr = 0
for r,l,i in qi:
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
ans[i] = BIT_query(r)-BIT_query(l-1)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| '''
自宅用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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n,q = list(map(int,ipt().split()))
# n = 5*10**5
# q = 5*10**5
# c = [int(i)+1 for i in range(n)]
c = [int(i) for i in ipt().split()]
qi = []
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append((r,l,i))
qi.sort()
ans = [-1]*q
ln = [-1]*(n+1)
bq_al = [0]*(n+1)
#Bit_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
pr = 0
for r,l,i in qi:
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
if bq_al[r] == 0:
bq_al[r] = BIT_query(r)
ans[i] = bq_al[r]-BIT_query(l-1)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| 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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n,q = list(map(int,ipt().split()))
# n = 5*10**5
# q = 5*10**5
# c = [int(i)+1 for i in range(n)]
c = [int(i) for i in ipt().split()]
qi = []
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append(r*10**14+l*10**7+i)
qi.sort()
ans = [-1]*q
ln = [-1]*(n+1)
bq_al = [0]*(n+1)
#Bit_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
pr = 0
for ist in qi:
i = ist%10**7
l = (ist//10**7)%10**7
r = ist//10**14
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
ans[i] = BIT_query(r)-BIT_query(l-1)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| '''
自宅用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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def main():
n,q = list(map(int,ipt().split()))
# n = 5*10**5
# q = 5*10**5
# c = [int(i)+1 for i in range(n)]
c = [int(i) for i in ipt().split()]
qi = []
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append(r*((10**6+1)**2)+l*(10**6+1)+i)
qi.sort()
ans = [0]*q
ln = [-1]*(n+1)
bq_al = [0]*(n+1)
#Bit_Indexed_Tree
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(n+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
pr = 0
for ist in qi:
i = ist%(10**6+1)
l = (ist//(10**6+1))%(10**6+1)
r = ist//(10**6+1)**2
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
ans[i] = BIT_query(r)-BIT_query(l-1)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| 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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def Mo(n,q,c,qi,base):
ans = [0]*q
ln = [-1]*(n+1)
#BITの構成
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
#Rが小さい方から見ていく,BITによる累積和の処理を含む
pr = 0
for ist in qi:
i = ist%(base)
l = (ist//(base))%(base)
r = ist//(base)**2
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
ans[i] = BIT_query(r)-BIT_query(l-1)
return ans
def main():
n,q = list(map(int,ipt().split()))
c = [int(i) for i in ipt().split()]
qi = []
base = 10**6+1
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append(r*(base**2)+l*base+i)
qi.sort()
ans = Mo(n,q,c,qi,10**6+1)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| '''
自宅用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
setrecursionlimit(10**7)
mod = 10**9+7
alp = "abcdefghijklmnopqrstuvwxyz"
def Mo(n,q,c,qi):
ans = [0]*q
ln = [-1]*(n+1)
#BITの構成
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
#Rが小さい方から見ていく,BITによる累積和の処理を含む
pr = 0
for i,l,r in qi:
for j in range(pr,r):
cj = c[j]
ij = ln[cj]
if ij != -1:
BIT_update(ij,-1)
ln[cj] = j+1
BIT_update(j+1,1)
pr = r
ans[i] = BIT_query(r)-BIT_query(l-1)
return ans
def main():
n,q = list(map(int,ipt().split()))
c = [int(i) for i in ipt().split()]
qi = []
base = 10**6+1
for i in range(q):
l,r = list(map(int,ipt().split()))
qi.append(r*(base**2)+l*base+i)
qi.sort()
qs = [(i%(base),(i//base)%base,i//(base**2))for i in qi]
ans = Mo(n,q,c,qs)
for i in ans:
print(i)
return None
if __name__ == '__main__':
main()
| 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っぽい感じなので)
def init(self, ls):
assert len(ls) <= self.n
# lsをbitの配列に入れる
for i, x in enumerate(ls): # O(n log n 掛かりそう)
self.add(i, x)
def add(self, i, x):
'''i番目の要素にxを足し込む'''
i += 1 # 1 based idxに直す
while i <= self.n:
self.bit[i] += x
i += (i & -i)
def sum(self, i, j):
'''[i,j)の区間の合計を取得'''
return self._sum(j) - self._sum(i)
def _sum(self, i):
'''[,i)の合計を取得'''
# 半開区間なので i+=1しなくていい
ret = 0
while i > 0:
ret += self.bit[i]
i -= (i & -i)
return ret
class RangeAddBIT: # range add query
# [l,r)にxを加算する
# [0,[l,r), i)のとき→bit.sum(i)+(rx-lx) (iによらない)
# [0,[l,i),r)のとき→bit.sum(i)+(ix-lx)
# [0,i),[l,r)のとき→bit.sum(i) (iによらない)
# を加算できれば良い。bit.sum(i)が0だと見立てるとわかりやすいかも？
# 場合分け2つ目における1項目をbit1,2項目をbit2とする
def __init__(self, n: int):
self.n = n
self.bit1 = BIT(n) # bit1.sum(i)*iで xiを達成したい部分 imos方的に使う
self.bit2 = BIT(n) # bit2.sum(i)で -xlを達成したい部分が手に入る。 r<iで区間加算後の和に相当する
def add(self, l: int, r: int, x):
'''[l,r)の要素にxを足し込む'''
self.bit1.add(l, x)
self.bit1.add(r, -x)
self.bit2.add(l, -x * l)
self.bit2.add(r, x * r)
def sum(self, l, r):
'''[l,r)の区間の合計を取得'''
return self._sum(r) - self._sum(l)
def _sum(self, i: int):
'''[,i)の合計を取得'''
return self.bit1._sum(i) * i + self.bit2._sum(i)
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from math import gcd
N, Q = ints()
C = ints()
L, R = read_col(Q)
query = defaultdict(lambda: list()) # lごとのqueryを格納しておく
for i, (l, r) in enu(zip(L, R)):
query[r].append((l - 1, i))
segtree = RangeAddBIT(N + 10) # l-rまでの種類数を格納(rを広げながら更新していく)
idxprev = defaultdict(lambda: -1) # 各色の前に出現したidx [prevの位置+1,再出現の位置+1)に区間加算する
ans = [-1] * Q
r_now = 0 # 現在の考慮する位置
for r in sorted(query.keys()):
for j in range(r_now, r):
prev = idxprev[C[j]]
segtree.add(prev + 1, j + 1, 1)
idxprev[C[j]] = j
r_now = j
for l, i in query[r]:
ans[i] = segtree.sum(l, l + 1)
print(*ans, sep='\n')
# TLEなんですけど...
| # 解説の解法は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っぽい感じなので)
def init(self, ls):
assert len(ls) <= self.n
# lsをbitの配列に入れる
for i, x in enumerate(ls): # O(n log n 掛かりそう)
self.add(i, x)
def add(self, i, x):
'''i番目の要素にxを足し込む'''
i += 1 # 1 based idxに直す
while i <= self.n:
self.bit[i] += x
i += (i & -i)
def sum(self, i, j):
'''[i,j)の区間の合計を取得'''
return self._sum(j) - self._sum(i)
def _sum(self, i):
'''[,i)の合計を取得'''
# 半開区間なので i+=1しなくていい
ret = 0
while i > 0:
ret += self.bit[i]
i -= (i & -i)
return ret
class RangeAddBIT: # range add query
# [l,r)にxを加算する
# [0,[l,r), i)のとき→bit.sum(i)+(rx-lx) (iによらない)
# [0,[l,i),r)のとき→bit.sum(i)+(ix-lx)
# [0,i),[l,r)のとき→bit.sum(i) (iによらない)
# を加算できれば良い。bit.sum(i)が0だと見立てるとわかりやすいかも？
# 場合分け2つ目における1項目をbit1,2項目をbit2とする
def __init__(self, n: int):
self.n = n
self.bit1 = BIT(n) # bit1.sum(i)*iで xiを達成したい部分 imos方的に使う
self.bit2 = BIT(n) # bit2.sum(i)で -xlを達成したい部分が手に入る。 r<iで区間加算後の和に相当する
def add(self, l: int, r: int, x):
'''[l,r)の要素にxを足し込む'''
self.bit1.add(l, x)
self.bit1.add(r, -x)
self.bit2.add(l, -x * l)
self.bit2.add(r, x * r)
def sum(self, l, r):
'''[l,r)の区間の合計を取得'''
return self._sum(r) - self._sum(l)
def _sum(self, i: int):
'''[,i)の合計を取得'''
return self.bit1._sum(i) * i + self.bit2._sum(i)
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_matrix(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter, xor, add
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from math import gcd
N, Q = ints()
C = ints()
L, R = read_col(Q)
query = defaultdict(lambda: list()) # lごとのqueryを格納しておく
for i, (l, r) in enu(zip(L, R)): # 普通にタプルのソートをするとTLEで死ぬので...
query[r].append((l - 1, i))
segtree = RangeAddBIT(N + 10) # l-rまでの種類数を格納(rを広げながら更新していく)
idxprev = defaultdict(lambda: -1) # 各色の前に出現したidx [prevの位置+1,再出現の位置+1)に区間加算する
ans = [-1] * Q
r_now = 0 # 現在の考慮する位置
for r in range(1, N + 1):
prev = idxprev[C[r - 1]]
segtree.add(prev + 1, r, 1)
idxprev[C[r - 1]] = r - 1
for l, i in query[r]:
ans[i] = segtree.sum(l, l + 1)
print(*ans, sep='\n')
# TLEぎりぎりなんですけど
| 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]
for _ in range(q):
l, r = list(map(int, input().split()))
if r == l:
print((1))
continue
l, r = l - 1, r - 1
y = cnt[l - 1] if l >= 1 else 0
z = rcnt[r] if r < n - 1 else 0
print((min(r - l + 1, max(cnt[r] - y, rcnt[l - 1] - z))))
solve()
| 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
return s
def update(self, i, x):
while i < self.n:
self.data[i] += x
i |= i + 1
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
odr_r = [[] for _ in range(n + 1)]
for i in range(q):
l, r = list(map(int, input().split()))
odr_r[r].append((l - 1, i))
b = BIT(n)
diff = 0
ans = [-1] * q
last = [-1] * (n + 1)
for i, v in enumerate(c):
if last[v] != -1:
b.update(last[v], -1)
else:
diff += 1
b.update(i, 1)
last[v] = i
for l, j in odr_r[i + 1]:
ans[j] = diff - b.sum(l)
print(("\n".join(map(str, ans))))
return
solve()
| 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:
:return:
"""
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
"""
[0,i]の合計
:param int i:
:return:
"""
res = 0
x = i + 1
while x > 0:
res += self.bit[x - 1]
x -= x & -x
return res
def search(self, x):
"""
二分探索。和がx以上となる最小のインデックス(>= 1)を返す
:param int x:
:return :
"""
i = 1
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i + step <= self.size and s + self.bit[i + step - 1] < x:
i += step
s += self.bit[i - 1]
step >>= 1
return i
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
lr = [list(map(int, input().split())) + [i] for i in range(q)]
lr.sort(key=lambda x:x[1])
BIT = BinaryIndexedTree(n+1)
LastAppeared = [-1] * (n+1)
ans = [0] * q
R = 0
for l, r, i in lr:
while R < r:
if LastAppeared[c[R]] != -1:
BIT.add(LastAppeared[c[R]], -1)
LastAppeared[c[R]] = R+1
BIT.add(R+1, 1)
R += 1
ans[i] = BIT.sum(r) - BIT.sum(l-1)
for i in ans:
print(i) | #!/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:
:return:
"""
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
"""
[0,i]の合計
:param int i:
:return:
"""
res = 0
x = i + 1
while x > 0:
res += self.bit[x - 1]
x -= x & -x
return res
def search(self, x):
"""
二分探索。和がx以上となる最小のインデックス(>= 1)を返す
:param int x:
:return :
"""
i = 1
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i + step <= self.size and s + self.bit[i + step - 1] < x:
i += step
s += self.bit[i - 1]
step >>= 1
return i
n, q = list(map(int, sys.stdin.readline().split()))
c = list(map(int, sys.stdin.readline().split()))
lr = [list(map(int, sys.stdin.readline().split())) + [i] for i in range(q)]
lr.sort(key=lambda x:x[1])
BIT = BinaryIndexedTree(n+1)
LastAppeared = [-1] * (n+1)
ans = [0] * q
R = 0
for l, r, i in lr:
while R < r:
if LastAppeared[c[R]] != -1:
BIT.add(LastAppeared[c[R]], -1)
LastAppeared[c[R]] = R+1
BIT.add(R+1, 1)
R += 1
ans[i] = BIT.sum(r) - BIT.sum(l-1)
for i in ans:
print(i) | 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
i += (i & -i)
def get(self, i, j):
return self.to_sum(j)-self.to_sum(i-1)
N,Q = map(int,input().split())
C = list(map(int,input().split()))
#print(C)
LR = []
ans = [0 for _ in range(Q)]
for i in range(Q):
temp= list(map(int,input().split()))
LR.append((temp,i)) #クエリとID
LR.sort(key=lambda x : x[0][1]) #右端で昇順にソート
#print(LR)
CMAX = max(C)
Tree = BIT(N)
last = [-1 for _ in range(CMAX)] #色を0index
left,right = LR[0][0]
for j in range(right):
mae = last[C[j]-1]
last[C[j]-1] = j
if mae !=-1:
Tree.add(mae+1,-1) #BITは1から
Tree.add(last[C[j]-1]+1,1) #BITは1から
#print(Tree.get(left,right))
#print(last)
D = []
#for i in range(1,N+1):
# detemp = Tree.get(i,i)
# D.append(detemp)
#print(D)
temp = Tree.get(left,right)
ID = LR[0][1]
ans[ID] = temp
lastright = right
#print(Tree.get(left,right))
for i in range(1,Q):
left,right = LR[i][0]
#print(right,lastright)
if lastright < right:
for j in range(lastright,right):
mae = last[C[j]-1]
last[C[j]-1] = j
#print(C[j],mae,j,last[C[j]-1] )
if mae !=-1:
#rint(C[j],"A")
Tree.add(mae+1,-1) #BITは1index
Tree.add(last[C[j]-1]+1,1) #BITは1index
ans[LR[i][1]] = Tree.get(left,right)
lastright = max(right,lastright)
#print(last)
print(*ans,sep="\n")
| 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
i += (i & -i)
def get(self, i, j):
return self.to_sum(j)-self.to_sum(i-1)
N,Q = map(int,input().split())
C = list(map(int,input().split()))
#print(C)
LR = []
ans = [0 for _ in range(Q)]
for i in range(Q):
temp= list(map(int,input().split()))
LR.append((temp,i)) #クエリとID
LR.sort(key=lambda x : x[0][1]) #右端で昇順にソート
#print(LR)
CMAX = max(C)
Tree = BIT(N)
last = [-1 for _ in range(CMAX)] #色を0index
left,right = LR[0][0]
for j in range(right):
mae = last[C[j]-1]
last[C[j]-1] = j
if mae !=-1:
Tree.add(mae+1,-1) #BITは1から
Tree.add(last[C[j]-1]+1,1) #BITは1から
#print(Tree.get(left,right))
#print(last)
D = []
#for i in range(1,N+1):
# detemp = Tree.get(i,i)
# D.append(detemp)
#print(D)
temp = Tree.get(left,right)
ID = LR[0][1]
ans[ID] = temp
lastright = right
#print(Tree.get(left,right))
for i in range(1,Q):
left,right = LR[i][0]
#print(right,lastright)
if lastright < right:
for j in range(lastright,right):
mae = last[C[j]-1]
last[C[j]-1] = j
#print(C[j],mae,j,last[C[j]-1] )
if mae !=-1:
#rint(C[j],"A")
Tree.add(mae+1,-1) #BITは1index
Tree.add(j+1,1) #BITは1index
temp = Tree.get(left,right)
ID = LR[i][1]
ans[ID] = temp
lastright = max(right,lastright)
#print(last)
print(*ans,sep="\n")
| 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
i += (i & -i)
def get(self, i, j):
return self.to_sum(j)-self.to_sum(i-1)
N,Q = map(int,input().split())
C = list(map(int,input().split()))
#print(C)
LR = []
ans = [0 for _ in range(Q)]
for i in range(Q):
temp= list(map(int,input().split()))
LR.append((temp,i)) #クエリとID
LR.sort(key=lambda x : x[0][1]) #右端で昇順にソート
#print(LR)
CMAX = max(C)
Tree = BIT(N)
last = [-1 for _ in range(CMAX)] #色を0index
left,right = LR[0][0]
for j in range(right):
mae = last[C[j]-1]
last[C[j]-1] = j
if mae !=-1:
Tree.add(mae+1,-1) #BITは1から
Tree.add(last[C[j]-1]+1,1) #BITは1から
#print(Tree.get(left,right))
#print(last)
D = []
#for i in range(1,N+1):
# detemp = Tree.get(i,i)
# D.append(detemp)
#print(D)
temp = Tree.get(left,right)
ID = LR[0][1]
ans[ID] = temp
lastright = right
#print(Tree.get(left,right))
for i in range(1,Q):
left,right = LR[i][0]
#print(right,lastright)
if lastright < right:
for j in range(lastright,right):
mae = last[C[j]-1]
last[C[j]-1] = j
#print(C[j],mae,j,last[C[j]-1] )
if mae !=-1:
#rint(C[j],"A")
Tree.add(mae+1,-1) #BITは1index
Tree.add(j+1,1) #BITは1index
temp = Tree.get(left,right)
ID = LR[i][1]
ans[ID] = temp
lastright = max(right,lastright)
#print(last)
print(*ans,sep="\n")
| 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
i += (i & -i)
def get(self, i, j):
return self.to_sum(j)-self.to_sum(i-1)
import sys
input = sys.stdin.readline
N,Q = map(int,input().split())
C = list(map(int,input().split()))
#print(C)
LR = []
ans = [0 for _ in range(Q)]
for i in range(Q):
temp= list(map(int,input().split()))
LR.append((temp,i)) #クエリとID
LR.sort(key=lambda x : x[0][1]) #右端で昇順にソート
#print(LR)
CMAX = max(C)
Tree = BIT(N)
last = [-1 for _ in range(CMAX)] #色を0index
left,right = LR[0][0]
for j in range(right):
mae = last[C[j]-1]
last[C[j]-1] = j
if mae !=-1:
Tree.add(mae+1,-1) #BITは1から
Tree.add(last[C[j]-1]+1,1) #BITは1から
#print(Tree.get(left,right))
#print(last)
D = []
#for i in range(1,N+1):
# detemp = Tree.get(i,i)
# D.append(detemp)
#print(D)
temp = Tree.get(left,right)
ID = LR[0][1]
ans[ID] = temp
lastright = right
#print(Tree.get(left,right))
for i in range(1,Q):
left,right = LR[i][0]
#print(right,lastright)
if lastright < right:
for j in range(lastright,right):
mae = last[C[j]-1]
last[C[j]-1] = j
#print(C[j],mae,j,last[C[j]-1] )
if mae !=-1:
#rint(C[j],"A")
Tree.add(mae+1,-1) #BITは1index
Tree.add(j+1,1) #BITは1index
temp = Tree.get(left,right)
ID = LR[i][1]
ans[ID] = temp
lastright = max(right,lastright)
#print(last)
print(*ans,sep="\n")
| 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
i += (i & -i)
def get(self, i, j):
return self.to_sum(j)-self.to_sum(i-1)
import sys
input = sys.stdin.readline
N,Q = map(int,input().split())
C = list(map(int,input().split()))
#print(C)
LR = []
ans = [0 for _ in range(Q)]
for i in range(Q):
temp= list(map(int,input().split()))
LR.append((temp,i)) #クエリとID
LR.sort(key=lambda x : x[0][1]) #右端で昇順にソート
#print(LR)
CMAX = max(C)
Tree = BIT(N)
last = [-1 for _ in range(CMAX)] #色を0index
left,right = LR[0][0]
for j in range(right):
mae = last[C[j]-1]
last[C[j]-1] = j
if mae !=-1:
Tree.add(mae+1,-1) #BITは1から
Tree.add(last[C[j]-1]+1,1) #BITは1から
#print(Tree.get(left,right))
#print(last)
D = []
#for i in range(1,N+1):
# detemp = Tree.get(i,i)
# D.append(detemp)
#print(D)
temp = Tree.get(left,right)
ID = LR[0][1]
ans[ID] = temp
lastright = right
#print(Tree.get(left,right))
for i in range(1,Q):
left,right = LR[i][0]
#print(right,lastright)
if lastright < right:
for j in range(lastright,right):
mae = last[C[j]-1]
last[C[j]-1] = j
#print(C[j],mae,j,last[C[j]-1] )
if mae !=-1:
#rint(C[j],"A")
Tree.add(mae+1,-1) #BITは1index
Tree.add(j+1,1) #BITは1index
temp = Tree.get(left,right)
ID = LR[i][1]
ans[ID] = temp
#lastright = max(right,lastright)
#print(last)
print(*ans,sep="\n")
| 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
i += (i & -i)
def get(self, i, j):
return self.to_sum(j)-self.to_sum(i-1)
import sys
input = sys.stdin.readline
N,Q = map(int,input().split())
C = list(map(int,input().split()))
#print(C)
LR = []
ans = [0 for _ in range(Q)]
for i in range(Q):
temp= list(map(int,input().split()))
LR.append((temp,i)) #クエリとID
LR.sort(key=lambda x : x[0][1]) #右端で昇順にソート
#print(LR)
CMAX = max(C)
Tree = BIT(N)
last = [-1 for _ in range(CMAX)] #色を0index
left,right = LR[0][0]
for j in range(right):
mae = last[C[j]-1]
last[C[j]-1] = j
if mae !=-1:
Tree.add(mae+1,-1) #BITは1から
Tree.add(last[C[j]-1]+1,1) #BITは1から
#print(Tree.get(left,right))
#print(last)
D = []
#for i in range(1,N+1):
# detemp = Tree.get(i,i)
# D.append(detemp)
#print(D)
temp = Tree.get(left,right)
ID = LR[0][1]
ans[ID] = temp
lastright = right
#print(Tree.get(left,right))
for i in range(1,Q):
left,right = LR[i][0]
#print(right,lastright)
if lastright < right:
for j in range(lastright,right):
mae = last[C[j]-1]
last[C[j]-1] = j
#print(C[j],mae,j,last[C[j]-1] )
if mae !=-1:
#rint(C[j],"A")
Tree.add(mae+1,-1) #BITは1index
Tree.add(j+1,1) #BITは1index
temp = Tree.get(left,right)
ID = LR[i][1]
ans[ID] = temp
lastright = right
#print(last)
print(*ans,sep="\n")
| 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)
return
def main():
N, Q = list(map( int, input().split()))
C = list( map( int, input().split()))
LR = [ tuple( map( int, input().split())) for _ in range(Q)]
LRI = []
for i, x in enumerate(LR):
LRI.append((x[1], x[0], i))
LRI.sort(key=lambda x:x[0])
lastAppend = [-1]*(N+1)
BIT = [0]*(N+1)
ANS = [0]*Q
now = 1
for r, l, i in LRI:
while now <= r:
c = C[now-1]
if lastAppend[c] == -1:
BIT_update(BIT, now, 1,N)
else:
BIT_update(BIT, now, 1,N)
BIT_update(BIT, lastAppend[c],-1,N)
lastAppend[c] = now
now += 1
ANS[i] = BIT_query(BIT,r) - BIT_query(BIT,l-1)
print(( "\n".join( map( str, ANS))))
if __name__ == '__main__':
main()
| #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)
return
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)
ANS = [0]*Q
now = 1
for r, l, i in LRI:
while now <= r:
c = C[now-1]
if lastAppend[c] == -1:
BIT_update(BIT, now, 1,N)
else:
BIT_update(BIT, now, 1,N)
BIT_update(BIT, lastAppend[c],-1,N)
lastAppend[c] = now
now += 1
ANS[i] = BIT_query(BIT,r) - BIT_query(BIT,l-1)
print(( "\n".join( map( str, ANS))))
if __name__ == '__main__':
main()
| 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までの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
for j in range(Q):
SUM = queries[j]
r = SUM // 10**15
SUM %= 10**15
l = SUM // 10**8
SUM %= 10**8
i =SUM
while curR < r:
curR += 1
last = lastAppeared[c[curR]]
if last != -1:
BIT_update(last,-1)
lastAppeared[c[curR]] = curR
BIT_update(curR,1)
ans[i] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i])) | 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(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append((l,r,q))
queries.sort(key = lambda x:x[1])
curR = 0
for i in range(Q):
l,r,q = queries[i]
while curR < r:
curR += 1
last = lastAppeared[c[curR]]
if last != -1:
BIT_update(last,-1)
lastAppeared[c[curR]] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i])) | 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(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append((l,r,q))
queries.sort(key = lambda x:x[1])
curR = 0
for i in range(Q):
l,r,q = queries[i]
while curR < r:
curR += 1
last = lastAppeared[c[curR]]
if last != -1:
BIT_update(last,-1)
lastAppeared[c[curR]] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i])) | 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(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append((l,r,q))
queries.sort(key = lambda x:x[1])
curR = 0
for i in range(Q):
l,r,q = queries[i]
while curR < r:
curR += 1
new = c[curR]
last = lastAppeared[new]
if last != -1:
BIT_update(last,-1)
lastAppeared[new] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i])) | 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(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**15+l*10**8+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**15
query %= 10**15
l = query//10**8
q = query % 10**8
while curR < r:
curR += 1
new = c[curR]
last = lastAppeared[new]
if last != -1:
BIT_update(last,-1)
lastAppeared[new] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i])) | 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 += idx&(-idx)
return
c = [-1]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**12
query %= 10**12
l = query//10**6
q = query % 10**6
while curR < r:
curR += 1
new = c[curR]
last = lastAppeared[new]
if last != -1:
BIT_update(last,-1)
lastAppeared[new] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i])) | 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 += idx&(-idx)
return
c = [0]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**12
query %= 10**12
l = query//10**6
q = query % 10**6
for R in range(curR+1,r+1):
color = c[R]
last = lastAppeared[color]
if last != -1:
BIT_update(last,-1)
lastAppeared[color] = R
BIT_update(R,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i]))
| 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 += idx&(-idx)
return
c = [0]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**12
query %= 10**12
l = query//10**6
q = query % 10**6
while curR < r:
curR += 1
color = c[curR]
last = lastAppeared[color]
if last != -1:
BIT_update(last,-1)
lastAppeared[color] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i]))
| 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 += idx&(-idx)
return
c = [0]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**12
query %= 10**12
l = query//10**6
q = query % 10**6
while curR < r:
curR += 1
color = c[curR]
last = lastAppeared[color]
if last != -1:
BIT_update(last,-1)
lastAppeared[color] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i]))
| 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 += idx&(-idx)
return
c = [-1]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**12
query %= 10**12
l = query//10**6
q = query % 10**6
while curR < r:
curR += 1
new = c[curR]
last = lastAppeared[new]
if last != -1:
BIT_update(last,-1)
lastAppeared[new] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i]))
| 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 += idx&(-idx)
return
c = [-1]+list(map(int,input().split()))
lastAppeared = [-1]*(N+1)
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q)
queries.sort()
curR = 0
for i in range(Q):
query = queries[i]
r = query//10**12
query %= 10**12
l = query//10**6
q = query % 10**6
while curR < r:
curR += 1
new = c[curR]
last = lastAppeared[new]
if last != -1:
BIT_update(last,-1)
lastAppeared[new] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1)
for i in range(Q):
print((ans[i]))
| 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 <= N:
BIT[idx] += x
idx += idx&(-idx)
return
c = [0]+list(map(int,input().split())) # 1-indexedで扱う
lastAppeared = [-1]*(N+1) # その色が最後に現れた位置
ans = [0]*Q
queries = []
for q in range(Q):
l,r = list(map(int,input().split()))
queries.append(r*10**12+l*10**6+q) # tupleのソートは遅いので6桁区切りでintにする
queries.sort() # rでソートされる
curR = 0 # 右端の位置
for i in range(Q):
query = queries[i]
r = query//10**12
l = (query//10**6)%(10**6)
q = query % 10**6
while curR < r:
curR += 1
color = c[curR]
last = lastAppeared[color]
if last != -1:
BIT_update(last,-1) # すでに現れているなら前に現れた位置から-1
lastAppeared[color] = curR
BIT_update(curR,1)
ans[q] = BIT_query(r)-BIT_query(l-1) # クエリを先読みしているのでansに格納
for i in range(Q):
print((ans[i]))
| 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:
out += self.array[x-1]
x -= x & -x
return out
################### ABC174F ###################
def main(N,Q,c,q):
bit = BIT(N)
rbi= {}
ans = [0]*Q
q.sort(key= lambda x:x[1])
R = 0
for l,r,ind in q:
for i in range(R,r):
if c[i] in rbi:
bit.add(rbi[c[i]],-1)
rbi[c[i]] = i+1
bit.add(rbi[c[i]],1)
ans[ind] = bit.sum(r)-bit.sum(l-1)
return ans
if __name__ == "__main__":
N,Q = list(map(int,input().split()))
c = list(map(int,input().split()))
q = list( list(map(int,input().split()))+[i] for i in range(Q))
ans = main(N,Q,c,q)
for i in ans:
print(i) | 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:
out += self.array[x-1]
x -= x & -x
return out
################### ABC174F ###################
def main(N,Q,c,q):
bit = BIT(N)
rbi= {}
ans = [0]*Q
q.sort(key= lambda x:x[1])
R = 0
for l,r,ind in q:
for i in range(R,r):
if c[i] in rbi:
bit.add(rbi[c[i]],-1)
rbi[c[i]] = i+1
bit.add(rbi[c[i]],1)
ans[ind] = bit.sum(r)-bit.sum(l-1)
R = r
return ans
if __name__ == "__main__":
N,Q = list(map(int,input().split()))
c = list(map(int,input().split()))
q = list( list(map(int,input().split()))+[i] for i in range(Q))
ans = main(N,Q,c,q)
for i in ans:
print(i) | 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 - 1
while i > 0:
s -= arr[i]
i -= i & -i
return s
def main():
n, q = map(int, read().split())
c = [int(i) - 1 for i in read().split()]
queries = [(0, 0, 0) for _ in range(q)]
for i in range(q):
l, r = map(int, read().split())
queries[i] = (i, l, r)
queries = iter(sorted(queries, key=itemgetter(2)))
last = [0] * n
bit = [0] * (n + 1)
ans = [-1] * q
k, l, r = next(queries)
for i in range(n):
ci = c[i]
li = last[ci]
if li > 0:
add(bit, li, -1)
last[ci] = i + 1
add(bit, i + 1, 1)
while i + 1 == r:
ans[k] = range_sum(bit, l, r)
try:
k, l, r = next(queries)
except StopIteration:
break
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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 = 0
i = b
while i > 0:
s += arr[i]
i -= i & -i
i = a - 1
while i > 0:
s -= arr[i]
i -= i & -i
return s
def main():
n, q = map(int, read().split())
c = [int(i) - 1 for i in read().split()]
queries = [(0, 0, 0) for _ in range(q)]
for i in range(q):
l, r = map(int, read().split())
queries[i] = (i, l, r)
queries = iter(sorted(queries, key=itemgetter(2)))
last = [0] * n
bit = [0] * (n + 1)
ans = [-1] * q
k, l, r = next(queries)
for i in range(n):
ci = c[i]
li = last[ci]
if li > 0:
sub(bit, li)
last[ci] = i + 1
add(bit, i + 1)
while i + 1 == r:
ans[k] = range_sum(bit, l, r)
try:
k, l, r = next(queries)
except StopIteration:
break
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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
queries = [[] for _ in [0]*(N+1)]
indices = [[] for _ in [0]*(N+1)]
for i in range(Q):
l, r = map(int, input().split())
queries[l].append(r)
indices[l].append(i)
def add(A, i, x):
while i <= N:
A[i] += x
i += i & -i
def sum(A, i):
ret = 0
while i:
ret += A[i]
i ^= i & -i
return ret
A = [0]*(N+1)
ans = [0]*Q
for l in range(N, 0, -1):
for cr in P[l]:
add(A, cr, 1)
for i, r in zip(indices[l], queries[l]):
ans[i] = r-l+1-sum(A, r)
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| 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)
last[c] = i+1
queries = [[] for _ in [0]*(N+1)]
for i in range(Q):
l, r = map(int, input().split())
queries[l].append((r, i))
def add(A, i, x):
while i <= N:
A[i] += x
i += i & -i
def sum(A, i):
ret = 0
while i:
ret += A[i]
i ^= i & -i
return ret
A = [0]*(N+1)
ans = [0]*Q
for l in range(N, 0, -1):
for cr in P[l]:
add(A, cr, 1)
for r, i in queries[l]:
ans[i] = r-l+1-sum(A, r)
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| 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 //= 2
Depth = len(FenwickTree)
def addElem(n,index): # add n to an element in index
for j in range(Depth):
FenwickTree[j][index] += n
index //= 2
def firstNSum(n): # Return the sum of the first n elements (0 to n-1)
nCpy = n
summ = 0
depthCur = 0
while nCpy != 0:
if nCpy % 2 != 0:
summ += FenwickTree[depthCur][nCpy - 1]
nCpy //= 2
depthCur += 1
return summ
c = list(map(int,input().split()))
firstLocColor = [-1] * N
ans = [-1] * Q
queries = []
for i in range(Q):
l,r = list(map(int,input().split()))
queries.append((l,r,i))
queries.sort(key = lambda x: x[1])
queryIndex = 0
for i in range(N):
# Update the Fenwick tree to count ith element
if firstLocColor[c[i] - 1] == -1:
addElem(1,i)
firstLocColor[c[i] - 1] = i
else:
addElem(-1,firstLocColor[c[i] - 1])
addElem(1,i)
firstLocColor[c[i] - 1] = i
# get query
while queryIndex < Q and queries[queryIndex][1] - 1 <= i:
if queries[queryIndex][1] - 1 == i:
ans[queries[queryIndex][2]] = firstNSum(queries[queryIndex][1]) - firstNSum(queries[queryIndex][0] - 1)
queryIndex += 1
for elem in ans:
print(elem) | # 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
Depth = len(FenwickTree)
def addElem(n,index): # add n to an element in index
for j in range(Depth):
if index < len(FenwickTree[j]):
FenwickTree[j][index] += n
index //= 2
def firstNSum(n): # Return the sum of the first n elements (0 to n-1)
nCpy = n
summ = 0
depthCur = 0
while nCpy != 0:
if nCpy % 2 != 0:
summ += FenwickTree[depthCur][nCpy - 1]
nCpy //= 2
depthCur += 1
return summ
c = list(map(int,input().split()))
firstLocColor = [-1] * N
ans = [-1] * Q
queries = []
for i in range(Q):
l,r = list(map(int,input().split()))
queries.append((l,r,i))
queries.sort(key = lambda x: x[1])
queryIndex = 0
for i in range(N):
# Update the Fenwick tree to count ith element
if firstLocColor[c[i] - 1] == -1:
addElem(1,i)
firstLocColor[c[i] - 1] = i
else:
addElem(-1,firstLocColor[c[i] - 1])
addElem(1,i)
firstLocColor[c[i] - 1] = i
# get query
while queryIndex < Q and queries[queryIndex][1] - 1 <= i:
if queries[queryIndex][1] - 1 == i:
ans[queries[queryIndex][2]] = firstNSum(queries[queryIndex][1]) - firstNSum(queries[queryIndex][0] - 1)
queryIndex += 1
for elem in ans:
print(elem) | 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))
return N, Q, C, LR
def solve(N, Q, C, LR):
Z = [Counter() for i in range(N+1)]
for i in range(N):
Z[i+1] = Z[i] + Counter([C[i]])
for l, r in LR:
z = Z[r]-Z[l-1]
print((len(z)))
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| 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))
return N, Q, C, LR
def solve(N, Q, C, LR, D=300):
Z = [Counter() for i in range(N//D+2)]
for i in range(0, N//D):
Z[i] = Counter(C[i*D:(i+1)*D])
for l, r in LR:
chunk_l = l // D
chunk_r = r // D
if chunk_r - chunk_l <= 1:
print((len(Counter(C[l:r]))))
else:
p1 = len(Counter(C[l:(chunk_l+1)*D]))
p3 = len(Counter(C[chunk_r*D:r]))
z = Counter()
for i in range(chunk_l+1, chunk_r):
z += Z[i]
p2 = len(z)
print((p1+p2+p3))
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| 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))
return N, Q, C, LR
def solve(N, Q, C, LR, D=300):
Z = [Counter() for i in range(N//D+2)]
for i in range(0, N//D):
Z[i] = Counter(C[i*D:(i+1)*D])
for l, r in LR:
chunk_l = l // D
chunk_r = r // D
if chunk_r - chunk_l <= 1:
print((len(Counter(C[l:r]))))
else:
p1 = len(Counter(C[l:(chunk_l+1)*D]))
p3 = len(Counter(C[chunk_r*D:r]))
z = Counter()
for i in range(chunk_l+1, chunk_r):
z += Z[i]
p2 = len(z)
print((p1+p2+p3))
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| 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())
treesize = n * 2
st = [init_value] * treesize
self.st = st
self.offset = len(st) // 2
@classmethod
def from_array(cls, a, op=min, init_value=10**8):
st = cls(len(a), op=op, init_value=init_value)
for i, x in enumerate(a):
st.update(i, x)
return st
def update(self, key, value):
"""値の更新"""
k = self.offset + key
self.st[k] = value
k >>= 1
while k > 0:
self.st[k] = self.op(self.st[k * 2], self.st[k * 2 + 1])
k >>= 1
def _query_bottomup(self, a, b):
"""区間[a, b) に対する累積操作
"""
a += self.offset
b += self.offset - 1
s = self.init_value
while a < b:
if a & 1:
s = self.op(s, self.st[a])
a += 1
a >>= 1
if not b & 1:
s = self.op(s, self.st[b])
b -= 1
b >>= 1
if a == b:
s = self.op(s, self.st[a])
return s
def _query_topdown(self, a, b, k=1, l=0, r=-1):
"""区間[a, b) に対する累積操作
k: 着目しているノード (1-indexed)
l: 探索区間 st[l, r) の左端 (0-indexed)
r: 探索区間 st[l, r) の右端 (0-indexed)
"""
if r == -1:
r = self.offset
if r <= a or b <= l:
return self.init_value
if a <= l and r <= b:
return self.st[k]
mid = (l + r) // 2
lv = self._query_topdown(a, b, k * 2, l, mid)
rv = self._query_topdown(a, b, k * 2 + 1, mid, r)
return self.op(lv, rv)
def query(self, a, b):
"""区間[a, b) に対する累積操作"""
if a > b:
raise ValueError("a must be less than equal b.")
return self._query_bottomup(a, b)
def read():
N, Q = list(map(int, input().strip().split()))
C = list(map(int, input().strip().split()))
# クエリ [l, r) とその順序を持っておく
LRI = []
for i in range(Q):
l, r = list(map(int, input().strip().split()))
LRI.append((l-1, r, i))
return N, Q, C, LRI
def solve(N, Q, C, LRI, INF=10**7):
prev = [-1 for i in range(N+1)]
ans = [0 for i in range(Q)]
rmq = RMQ(N, op=add, init_value=0)
# Rの昇順にソート
LRI.sort(key=itemgetter(1))
r_prev = 0
for l, r, i in LRI:
for j in range(r_prev, r):
c = C[j]
# A[prev[c]] = 0
if prev[c] != -1:
rmq.update(prev[c], 0)
prev[c] = j
# A[j] = 1
rmq.update(j, 1)
r_prev = r
ans[i] = rmq.query(l, r)
for a in ans:
print(a)
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print(("%s" % str(outputs)))
| 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:
return 0
s = 0
while i > 0:
s += self._container[i]
i -= i & (-i)
return s
def add(self, i, x):
if i == 0:
return
while i <= self.size:
self._container[i] += x
i += i & (-i)
def lower_bound(self, x):
if x == 0:
return 0
s = 0
idx = 0
for i in range(self.depth, -1, -1):
k = idx + (1 << i)
if k <= self.size and s + self._container[k] < x:
s += self._container[k]
idx += 1 << i
return idx + 1
def __repr__(self):
return str(self._container)
def main():
from collections import deque
from operator import itemgetter
n, q = list(map(int, readline().split()))
c = list(map(int, readline().split()))
res = [0] * n
query = [[None] for _ in range(q)]
for i in range(q):
l, r = list(map(int, readline().split()))
query[i] = (l, r, i)
bt = BinaryIndexTree(n)
query.sort()
idx = {i: deque() for i in range(1, n + 1)}
for i, x in enumerate(c, 1):
idx[x].append(i)
for num in range(1, n + 1):
if idx[num]:
bt.add(idx[num][0], 1)
l_cur = 1
for i in range(q):
l, r, j = query[i]
while l_cur < l:
num = c[l_cur - 1]
if len(idx[num]) > 1:
bt.add(idx[num].popleft(), -1)
bt.add(idx[num][0], 1)
else:
bt.add(idx[num].popleft(), -1)
l_cur += 1
res[j] = bt.sum(r)
for i in range(q):
print((res[i]))
if __name__ == '__main__':
main()
| 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.depth = n.bit_length()
def sum(self, i):
if i == 0:
return 0
s = 0
while i > 0:
s += self._container[i]
i -= i & (-i)
return s
def add(self, i, x):
if i == 0:
return
while i <= self.size:
self._container[i] += x
i += i & (-i)
def lower_bound(self, x):
if x == 0:
return 0
s = 0
idx = 0
for i in range(self.depth, -1, -1):
k = idx + (1 << i)
if k <= self.size and s + self._container[k] < x:
s += self._container[k]
idx += 1 << i
return idx + 1
def __repr__(self):
return str(self._container)
n, q = list(map(int, readline().split()))
c = [0] + list(map(int, readline().split()))
query = []
for i in range(q):
l, r = list(map(int, readline().split()))
query.append((l, r, i))
query.sort(key=itemgetter(1))
idx = dict()
cur = 0
bit = BinaryIndexTree(n)
res = [0] * q
s = 0
for i in range(q):
l, r, j = query[i]
while cur < r:
cur += 1
color = c[cur]
if idx.get(color):
bit.add(idx[color], -1)
else:
s += 1
bit.add(cur, 1)
idx[color] = cur
res[j] = s - bit.sum(l - 1)
for i in range(q):
print((res[i]))
if __name__ == '__main__':
main()
| 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] * (n + 1) # 内部的には1-indexで扱う
def add(self, i, x): # 0-index
i += 1 # 内部的には1-indexで扱う
while i <= self.size:
self.tree[i] += x
i += i & -i
def sum(self, i): # 0-index sum of [0,i)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def query(self, l, r): # 0-index sum of [l,r)
return self.sum(r) - self.sum(l)
# ---------------------- #
n, q = (int(x) for x in input().split())
C = list(int(x) - 1 for x in input().split())
LR = [tuple(int(x) for x in input().split()) for _ in range(q)]
bit = BinaryIndexedTree(n)
color_right_index = [-1] * n
queries = [(i, l - 1, r - 1) for i, (l, r) in enumerate(LR)]
queries.sort(key=itemgetter(2))
ANS = [0] * q
k = 0
for i, l, r in queries:
while k <= r and k <= n:
color = C[k]
if color_right_index[color] != -1:
bit.add(color_right_index[color], -1)
color_right_index[C[k]] = k
bit.add(k, 1)
k += 1
ANS[i] = bit.query(l, r + 1)
for ans in ANS:
print(ans)
| 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で扱う
while i <= self.size:
self.tree[i] += x
i += i & -i
def sum(self, i): # 0-index sum of [0,i)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def query(self, l, r): # 0-index sum of [l,r)
return self.sum(r) - self.sum(l)
# ---------------------- #
n, q = (int(x) for x in input().split())
C = list(int(x) - 1 for x in input().split())
LR = [tuple(int(x) for x in input().split()) for _ in range(q)]
bit = BinaryIndexedTree(n)
color_right_index = [-1] * n
queries = [(i, l - 1, r - 1) for i, (l, r) in enumerate(LR)]
queries.sort(key=itemgetter(2))
ANS = [0] * q
k = 0
for i, l, r in queries:
while k <= r and k <= n:
color = C[k]
if color_right_index[color] != -1:
bit.add(color_right_index[color], -1)
color_right_index[C[k]] = k
bit.add(k, 1)
k += 1
ANS[i] = bit.query(l, r + 1)
for ans in ANS:
print(ans)
| 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
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class SegmentTree:
"""Segment Tree (Point Update & Range Query)
Query
1. update(i, val): update i-th value(0-indexed) to val
2. query(low, high): find f(value) in [low, high)
Complexity
time complexity: O(log n)
space complexity: O(n)
"""
def __init__(self, N, f, default):
self.N = 1 << (N-1).bit_length()
self.default = default
self.f = f
self.segtree = [self.default] * ((self.N << 1) - 1)
@classmethod
def create_from_array(cls, arr, f, default):
N = len(arr)
self = cls(N, f, default)
for i in range(N):
self.segtree[self.N - 1 + i] = arr[i]
for i in reversed(range(self.N - 1)):
self.segtree[i] = self.f(
self.segtree[(i << 1) + 1], self.segtree[(i << 1) + 2])
return self
def update(self, i, val): # update
i += self.N - 1
self.segtree[i] = val
while i > 0:
i = (i - 1) >> 1
self.segtree[i] = self.f(
self.segtree[(i << 1)+1], self.segtree[(i << 1)+2])
def query(self, low, high): # query
# query [l, r)
low, high = low + self.N, high + self.N
ret = self.default
while low < high:
if low & 1:
ret = self.f(ret, self.segtree[low-1])
low += 1
if high & 1:
high -= 1
ret = self.f(ret, self.segtree[high-1])
low, high = low >> 1, high >> 1
return ret
def get(self, k): # get k-th value(0-indexed)
return self.segtree[k+self.N-1]
def all(self): # all range query
return self.segtree[0]
N, Q = MAP()
c = LIST()
segtree = SegmentTree(N+1, lambda x,y:x|y, set())
for i, x in enumerate(c):
segtree.update(i, set([x]))
ans = [0]*Q
for i in range(Q):
l, r = MAP()
ans[i] = len(segtree.query(l-1, r))
print(*ans, sep="\n")
| 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
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i): # 区間 [1, i]の和
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x): # iにxを加算
while i <= self.size:
self.tree[i] += x
i += i & -i
def pos(self, idx): # idxの値を取得
return self.sum(idx) - self.sum(idx-1)
def lower_bound(self, w): # w以上の値を持つ最小のidxを検索
if w <= 0:
return 0
idx = 0
k = 1
while k*2 <= self.size:
k *= 2
while k > 0:
if idx+k <= self.size and self.tree[idx+k] < w:
w -= self.tree[idx+k]
idx += k
k //= 2
return idx+1
N, Q = MAP()
c = LIST()
ilr = [[i]+LIST() for i, _ in enumerate(range(Q))]
ilr.sort(key=lambda x:x[2])
bit = Bit(N)
rtmp = ilr[0][2]
last = [None]*(N+1)
for i in range(rtmp):
last[c[i]] = i+1
for i in range(1, N+1):
if last[i]:
bit.add(last[i], 1)
ans = [0]*Q
for i, l, r in ilr:
if rtmp < r:
for j in range(rtmp+1, r+1):
if last[c[j-1]]:
bit.add(last[c[j-1]], -1)
last[c[j-1]] = j
bit.add(j, 1)
rtmp = r
ans[i] = bit.sum(r)-bit.sum(l-1)
print(*ans, sep="\n")
| 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
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i): # 区間 [1, i]の和
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x): # iにxを加算
while i <= self.size:
self.tree[i] += x
i += i & -i
def pos(self, idx): # idxの値を取得
return self.sum(idx) - self.sum(idx-1)
def lower_bound(self, w): # w以上の値を持つ最小のidxを検索
if w <= 0:
return 0
idx = 0
k = 1
while k*2 <= self.size:
k *= 2
while k > 0:
if idx+k <= self.size and self.tree[idx+k] < w:
w -= self.tree[idx+k]
idx += k
k //= 2
return idx+1
N, Q = MAP()
c = LIST()
ilr = [[i]+LIST() for i, _ in enumerate(range(Q))]
ilr.sort(key=lambda x:x[2])
bit = Bit(N)
rtmp = ilr[0][2]
last = [None]*(N+1)
for i in range(rtmp):
last[c[i]] = i+1
for i in range(1, N+1):
if last[i]:
bit.add(last[i], 1)
ans = [0]*Q
for i, l, r in ilr:
if rtmp < r:
for j in range(rtmp+1, r+1):
if last[c[j-1]]:
bit.add(last[c[j-1]], -1)
last[c[j-1]] = j
bit.add(j, 1)
rtmp = r
ans[i] = bit.sum(r)-bit.sum(l-1)
print(*ans, sep="\n")
| 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
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i): # 区間 [1, i]の和
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x): # iにxを加算
while i <= self.size:
self.tree[i] += x
i += i & -i
def pos(self, idx): # idxの値を取得
return self.sum(idx) - self.sum(idx-1)
def lower_bound(self, w): # w以上の値を持つ最小のidxを検索
if w <= 0:
return 0
idx = 0
k = 1
while k*2 <= self.size:
k *= 2
while k > 0:
if idx+k <= self.size and self.tree[idx+k] < w:
w -= self.tree[idx+k]
idx += k
k //= 2
return idx+1
N, Q = MAP()
c = LIST()
ps = [[] for _ in range(N+1)]
qs = [[] for _ in range(N+1)]
for i in range(Q):
l, r = MAP()
qs[l].append((r, i))
checked = [-1]*(N+1)
for i, x in enumerate(c):
if checked[x] != -1:
ps[checked[x]].append(i+1)
checked[x] = i+1
ans = [-1]*Q
bit = Bit(N)
for x in range(N, 0, -1):
for y in ps[x]:
bit.add(y, 1)
for r, i in qs[x]:
ans[i] = r-x+1-bit.sum(r)
print(*ans, sep="\n")
| 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,-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
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
def popcnt(n):
c = (n & 0x5555555555555555) + ((n>>1) & 0x5555555555555555)
c = (c & 0x3333333333333333) + ((c>>2) & 0x3333333333333333)
c = (c & 0x0f0f0f0f0f0f0f0f) + ((c>>4) & 0x0f0f0f0f0f0f0f0f)
c = (c & 0x00ff00ff00ff00ff) + ((c>>8) & 0x00ff00ff00ff00ff)
c = (c & 0x0000ffff0000ffff) + ((c>>16) & 0x0000ffff0000ffff)
c = (c & 0x00000000ffffffff) + ((c>>32) & 0x00000000ffffffff)
return c
for i in range(n):
update(i,1<<c[i])
for i in range(Q):
l,r = list(map(int,input().split()))
l -= 1
res = query(l,r)
print((popcnt(res))) | 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)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= n:
BIT[idx] += x
idx += idx&(-idx)
return
fi = [[] for i in range(n+1)]
nxt = [-1]*(n+1)
for i in range(1,n+1):
num = c[i]
if len(fi[num]) == 0:
BIT_update(i,1)
else:
nxt[fi[num][-1]] = i
fi[num].append(i)
idx = 0
for i in range(1,n+1):
while idx < Q:
l,ri = divmod(LRI[idx],dg2)
if l != i:
break
r,resi = divmod(ri,dg)
res[resi] = BIT_query(r)
idx += 1
BIT_update(i,-1)
if nxt[i] != -1:
BIT_update(nxt[i],1)
print(*res,sep='\n')
| 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] += x
i += i & -i
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
lr = []
for i in range(Q):
l, r = list(map(int, input().split()))
lr.append([l, r, i])
lr.sort(key=lambda x: x[1])
# print("lr", lr)
rightest = [-1] * (N + 1)
current_q = 0
bit = Bit(N)
ans = [0] * Q
for i in range(N):
if rightest[c[i]] != -1:
bit.add(rightest[c[i]] + 1, -1)
rightest[c[i]] = i
bit.add(i + 1, 1)
# print(bit.tree)
while current_q < Q and lr[current_q][1] == i + 1:
ans[lr[current_q][2]] = bit.sum(lr[current_q][1]) - bit.sum(lr[current_q][0] - 1)
current_q += 1
for i in range(Q):
print((ans[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):
while i <= self.size:
self.tree[i] += x
i += i & -i
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
lr = []
for i in range(Q):
l, r = list(map(int, input().split()))
lr.append([l, r, i])
lr.sort(key=lambda x: x[1])
# print("lr", lr)
rightest = [-1] * (N + 1)
current_q = 0
bit = Bit(N)
ans = [0] * Q
for i in range(N):
if rightest[c[i]] != -1:
bit.add(rightest[c[i]] + 1, -1)
rightest[c[i]] = i
bit.add(i + 1, 1)
# print(bit.tree)
while current_q < Q and lr[current_q][1] == i + 1:
ans[lr[current_q][2]] = bit.sum(lr[current_q][1]) - bit.sum(lr[current_q][0] - 1)
current_q += 1
for i in range(Q):
print((ans[i]))
| 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):
while i <= self.size:
self.tree[i] += x
i += i & -i
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
lr = []
for i in range(Q):
l, r = list(map(int, input().split()))
lr.append([l, r, i])
lr.sort(key=lambda x: x[1])
# print("lr", lr)
rightest = [-1] * (N + 1)
current_q = 0
bit = Bit(N)
ans = [0] * Q
for i in range(N):
if rightest[c[i]] != -1:
bit.add(rightest[c[i]] + 1, -1)
rightest[c[i]] = i
bit.add(i + 1, 1)
# print(bit.tree)
while current_q < Q and lr[current_q][1] == i + 1:
ans[lr[current_q][2]] = bit.sum(lr[current_q][1]) - bit.sum(lr[current_q][0] - 1)
current_q += 1
for i in range(Q):
print((ans[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):
while i <= self.size:
self.tree[i] += x
i += i & -i
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
lr = []
for i in range(Q):
l, r = list(map(int, input().split()))
lr.append([l, r, i])
lr.sort(key=lambda x: x[1])
# print("lr", lr)
rightest = [-1] * (N + 1)
current_q = 0
bit = Bit(N)
ans = [0] * Q
for i in range(N):
if rightest[c[i]] != -1:
bit.add(rightest[c[i]] + 1, -1)
rightest[c[i]] = i
bit.add(i + 1, 1)
# print(bit.tree)
while current_q < Q and lr[current_q][1] == i + 1:
ans[lr[current_q][2]] = bit.sum(lr[current_q][1]) - bit.sum(lr[current_q][0] - 1)
current_q += 1
for i in range(Q):
print((ans[i]))
| 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):
j = Query[i] % (SHIFT)
Query[i] >>= 20
le = Query[i] % (SHIFT)
Query[i] >>= 20
ri = Query[i]
Query[i] = (le, ri, j)
def sum(tree, i):
s = 0
while i > 0:
s += tree[i]
i -= i & -i
return s
def add(tree, i, x):
while i <= N:
tree[i] += x
i += i & -i
lastappend = [-1] * (N + 1)
bit = [0] * (N + 1)
idx = 0 # Queryのindex
ans = []
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
add(bit, lastappend[a], -1)
lastappend[a] = i
add(bit, i, 1)
while idx < Q and i == Query[idx][1]:
(le, ri, j) = Query[idx]
ans.append((j, sum(bit, ri) - sum(bit, le-1)))
idx += 1
ans.sort()
for _, a in ans:
print(a)
if __name__ == '__main__':
main()
| 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):
j = Query[i] % (SHIFT)
Query[i] >>= 20
le = Query[i] % (SHIFT)
Query[i] >>= 20
ri = Query[i]
Query[i] = (le, ri, j)
Query.append((-1, -1, -1))
def sum(tree, i):
s = 0
while i > 0:
s += tree[i]
i -= i & -i
return s
def add(tree, i, x):
while i <= N:
tree[i] += x
i += i & -i
lastappend = [-1] * (N + 1)
bit = [0] * (N + 1)
idx = 0 # Queryのindex
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
add(bit, lastappend[a], -1)
lastappend[a] = i
add(bit, i, 1)
while i == Query[idx][1]:
(le, ri, j) = Query[idx]
ans[j] = sum(bit, ri) - sum(bit, le-1)
idx += 1
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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):
j = Query[i] % (SHIFT)
Query[i] >>= 20
le = Query[i] % (SHIFT)
Query[i] >>= 20
ri = Query[i]
Query[i] = (le, ri, j)
Query.append((-1, -1, -1))
def sum(tree, i):
s = 0
while i > 0:
s += tree[i]
i -= i & -i
return s
def add(tree, i, x):
while i <= N:
tree[i] += x
i += i & -i
lastappend = [-1] * (N + 1)
bit = [0] * (N + 1)
idx = 0 # Queryのindex
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
add(bit, lastappend[a], -1)
lastappend[a] = i
add(bit, i, 1)
while i == Query[idx][1]:
(le, ri, j) = Query[idx]
ans[j] = sum(bit, ri) - sum(bit, le-1)
idx += 1
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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 & (-i)
return s
def sum_acc(self, i, j):
""" [i,j] の和を返す """
return self.sum_until(j) - self.sum_until(i-1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
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):
j = Query[i] % (SHIFT)
Query[i] >>= 20
le = Query[i] % (SHIFT)
Query[i] >>= 20
ri = Query[i]
Query[i] = (le, ri, j)
Query.append((-1, -1, -1))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
idx = 0 # Queryのindex
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
while i == Query[idx][1]:
(le, ri, j) = Query[idx]
ans[j] = bit.sum_acc(le, ri)
idx += 1
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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)
return s
def sum_acc(self, i, j):
""" [i,j] の和を返す """
return self.sum_until(j) - self.sum_until(i-1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = [[] for _ in range(N+1)]
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query[ri].append((le, j))
Query.append((-1, -1, -1))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
for (le, j) in Query[i]:
ri = i
ans[j] = bit.sum_acc(le, ri)
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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)
return s
def sum_acc(self, i, j):
""" [i,j] の和を返す """
return self.sum_until(j) - self.sum_until(i-1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = [[] for _ in range(N+1)]
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query[ri].append((le, j))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
for (le, j) in Query[i]:
ri = i
ans[j] = bit.sum_acc(le, ri)
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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.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] += x
i += i & -i
B = Bit(n+1)
ANS = [-1] * q
C.sort(key=lambda x:x[1])
G = [-1] * (max(A)+1)
ind = 0
for i in range(n):
a = A[i]
if G[a] != -1:
# print("ADD", G[a]+1, -1)
B.add(G[a]+1, -1)
G[a] = i
# print("ADD", G[a]+1, 1)
B.add(G[a]+1, 1)
while ind < q and C[ind][1] == i:
# print("SUM", C[ind][1]+1, C[ind][0]+1-1)
ANS[C[ind][2]] = B.sum(C[ind][1]+1) - B.sum(C[ind][0]+1-1)
ind += 1
for i in range(q):
print((ANS[i])) | 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):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def __getitem__(self, i):
"""
[0,i)
"""
if isinstance(i, slice):
if i.start is None:
return self._get_sum(i.stop)
else:
return self._get_sum(i.stop) - self._get_sum(i.start)
else:
return 0 # fake value
__setitem__ = _add
def bisect_left(self, v):
"""
return smallest i s.t v <= sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] < v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
def bisect_right(self, v):
"""
return smallest i s.t v < sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] <= v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
bisect = bisect_right
def solve(C, queries):
N = len(C)
bit = BinaryIndexedTree(N)
last_ind = [None]*(5*10**5 + 1)
queries = sorted(((r,l-1,i) for i,(l,r) in enumerate(queries)), key=lambda x:x[0])
qi = 0
res = [None]*len(queries)
for i,c in enumerate(C):
li = last_ind[c]
if li is not None:
bit[li] -= 1
last_ind[c] = i
bit[i] += 1
while qi < len(queries) and queries[qi][0] == i+1:
res[queries[qi][2]] = bit[queries[qi][1]:i+1]
qi += 1
if qi == len(queries):
break
return res
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
if __name__ == '__main__':
N,Q = map(int,readline().split())
C = list(map(int,readline().split()))
m = map(int,read().split())
queries = list(zip(m,m))
print(*solve(C,queries), sep='\n')
| 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 _get_sum(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def __getitem__(self, i):
"""
[0,i)
"""
if isinstance(i, slice):
if i.start is None:
return self._get_sum(i.stop)
else:
return self._get_sum(i.stop) - self._get_sum(i.start)
else:
return 0 # fake value
__setitem__ = _add
def bisect_left(self, v):
"""
return smallest i s.t v <= sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] < v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
def bisect_right(self, v):
"""
return smallest i s.t v < sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] <= v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
bisect = bisect_right
def solve(C, queries):
N = len(C)
Q = len(queries)
bit = BinaryIndexedTree(N)
last_ind = [None]*(N + 1)
sorted_qi = sorted(range(Q), key=lambda i:queries[i][1])
res = [None]*Q
pr = 0
temp = 0
for qi in sorted_qi:
l,r = queries[qi]
for j,c in enumerate(C[pr:r],start=pr):
c = C[j]
if last_ind[c] is not None:
bit._add(last_ind[c], -1)
else:
temp += 1
last_ind[c] = j
bit._add(j, 1)
pr = r
res[qi] = temp - bit._get_sum(l-1)
return res
# from random import randrange, seed
# from time import perf_counter
# def test():
# seed(1234)
# N = 5*10**5
# C = [randrange(N) for _ in range(N)]
# queries = [tuple(sorted((randrange(1,N+1),randrange(1,N+1)))) for _ in range(N)]
# start = perf_counter()
# solve(C,queries)
# stop = perf_counter()
# print(stop-start)
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
if __name__ == '__main__':
N,Q = map(int,readline().split())
C = list(map(int,readline().split()))
m = map(int,read().split())
queries = list(zip(m,m))
print(*solve(C,queries), sep='\n')
# test()
| 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 _get_sum(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def __getitem__(self, i):
"""
[0,i)
"""
if isinstance(i, slice):
if i.start is None:
return self._get_sum(i.stop)
else:
return self._get_sum(i.stop) - self._get_sum(i.start)
else:
return 0 # fake value
__setitem__ = _add
def bisect_left(self, v):
"""
return smallest i s.t v <= sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] < v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
def bisect_right(self, v):
"""
return smallest i s.t v < sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] <= v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
bisect = bisect_right
def solve(C, queries):
N = len(C)
Q = len(queries)
bit = BinaryIndexedTree(N)
last_ind = [None]*(N + 1)
sorted_qi = sorted(range(Q), key=lambda i:queries[i][1])
res = [None]*Q
pr = 0
temp = 0
for qi in sorted_qi:
l,r = queries[qi]
for j in range(pr,r):
c = C[j]
if last_ind[c] is not None:
bit._add(last_ind[c], -1)
else:
temp += 1
last_ind[c] = j
bit._add(j, 1)
pr = r
res[qi] = temp - bit._get_sum(l-1)
return res
# from random import randrange, seed
# from time import perf_counter
# def test():
# seed(1234)
# N = 5*10**5
# C = [randrange(N) for _ in range(N)]
# queries = [tuple(sorted((randrange(1,N+1),randrange(1,N+1)))) for _ in range(N)]
# start = perf_counter()
# solve(C,queries)
# stop = perf_counter()
# print(stop-start)
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
if __name__ == '__main__':
N,Q = map(int,readline().split())
C = list(map(int,readline().split()))
m = map(int,read().split())
queries = list(zip(m,m))
print(*solve(C,queries), sep='\n')
# test()
| 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 _get_sum(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
def __getitem__(self, i):
"""
[0,i)
"""
if isinstance(i, slice):
if i.start is None:
return self._get_sum(i.stop)
else:
return self._get_sum(i.stop) - self._get_sum(i.start)
else:
return 0 # fake value
__setitem__ = _add
def bisect_left(self, v):
"""
return smallest i s.t v <= sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] < v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
def bisect_right(self, v):
"""
return smallest i s.t v < sum[:i]
"""
i = 0
k = self.msb
while k > 0:
i += k
if i < len(self.data) and self.data[i] <= v:
v -= self.data[i]
else:
i -= k
k >>= 1
return i
bisect = bisect_right
def solve(C, queries):
N = len(C)
Q = len(queries)
bit = BinaryIndexedTree(N)
last_ind = [None]*(N + 1)
res = [None]*Q
pr = 0
temp = 0
MASK = (1<<20)-1
for ri in sorted((r << 20)|i for i,(l,r) in enumerate(queries)):
qi = ri&MASK
l,r = queries[qi]
for j in range(pr,r):
c = C[j]
if last_ind[c] is not None:
bit._add(last_ind[c], -1)
else:
temp += 1
last_ind[c] = j
bit._add(j, 1)
pr = r
res[qi] = temp - bit._get_sum(l-1)
return res
# from random import randrange, seed
# from time import perf_counter
# def test():
# seed(1234)
# N = 5*10**5
# C = [randrange(N) for _ in range(N)]
# queries = [tuple(sorted((randrange(1,N+1),randrange(1,N+1)))) for _ in range(N)]
# start = perf_counter()
# solve(C,queries)
# stop = perf_counter()
# print(stop-start)
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
if __name__ == '__main__':
N,Q = map(int,readline().split())
C = list(map(int,readline().split()))
m = map(int,read().split())
queries = list(zip(m,m))
print(*solve(C,queries), sep='\n')
# test()
| 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 ** (vlen-1).bit_length()
self.tree = [ie]*self.size + self.values + [ie]*(self.size-vlen)
self.ie = ie
for i in range(self.size-1, 0, -1):
self.tree[i] = self.op(self.tree[i*2], self.tree[i*2+1])
def update(self, i, v):
i += self.size
self.tree[i] = v
while i > 0:
i //= 2
self.tree[i] = self.op(self.tree[i*2], self.tree[i*2+1])
def query(self, l, r):
l += self.size
r += self.size
ret = self.ie
while l < r:
if l & 1:
ret = self.op(ret, self.tree[l])
l += 1
if r & 1:
r -= 1
ret = self.op(ret, self.tree[r])
l //= 2
r //= 2
return ret
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
q = [[] for _ in range(N+1)]
for i in range(Q):
x, y = list(map(int, input().split()))
q[y-1].append([i, x-1])
st = SegmentTree([0]*(N+1), add, 0)
finds = [-1]*(N+1)
ans = [0]*Q
for i in range(N):
if finds[c[i]] != -1:
st.update(finds[c[i]], 0)
finds[c[i]] = i
st.update(finds[c[i]], 1)
for j, x in q[i]:
ans[j] = st.query(x, i+1)
for a in ans:
print(a)
| 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()
self.tree = [0]*self.size + self.values + [0]*(self.size-vlen)
for i in range(self.size-1, 0, -1):
self.tree[i] = self.tree[i*2] + self.tree[i*2+1]
def update(self, i, v):
i += self.size
self.tree[i] = v
while i > 0:
i //= 2
self.tree[i] = self.tree[i*2] + self.tree[i*2+1]
def query(self, l, r):
l += self.size
r += self.size
ret = 0
while l < r:
if l & 1:
ret += self.tree[l]
l += 1
if r & 1:
r -= 1
ret += self.tree[r]
l //= 2
r //= 2
return ret
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
q = [[] for _ in range(N+1)]
for i in range(Q):
x, y = list(map(int, input().split()))
q[y-1].append([i, x-1])
st = SegmentTree([0]*(N+1))
finds = [-1]*(N+1)
ans = [0]*Q
for i in range(N):
if finds[c[i]] != -1:
st.update(finds[c[i]], 0)
finds[c[i]] = i
st.update(finds[c[i]], 1)
for j, x in q[i]:
ans[j] = st.query(x, i+1)
for a in ans:
print(a)
| 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()
self.tree = [0]*self.size + self.values + [0]*(self.size-vlen)
for i in range(self.size-1, 0, -1):
self.tree[i] = self.tree[i*2] + self.tree[i*2+1]
def update(self, i, v):
i += self.size
self.tree[i] = v
while i > 0:
i //= 2
self.tree[i] = self.tree[i*2] + self.tree[i*2+1]
def query(self, l, r):
l += self.size
r += self.size
ret = 0
while l < r:
if l & 1:
ret += self.tree[l]
l += 1
if r & 1:
r -= 1
ret += self.tree[r]
l //= 2
r //= 2
return ret
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
q = [[] for _ in range(N+1)]
for i in range(Q):
x, y = list(map(int, input().split()))
q[y-1].append([i, x-1])
st = SegmentTree([0]*(N+1))
finds = [-1]*(N+1)
ans = [0]*Q
for i in range(N):
if finds[c[i]] != -1:
st.update(finds[c[i]], 0)
finds[c[i]] = i
st.update(finds[c[i]], 1)
for j, x in q[i]:
ans[j] = st.query(x, i+1)
for a in ans:
print(a)
| 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 & (-i)
return v
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
q = [[] for _ in range(N+1)]
for i in range(Q):
x, y = list(map(int, input().split()))
q[y-1].append([i, x-1])
bit = BIT(N)
finds = [-1]*(N+1)
ans = [0]*Q
for i in range(N):
if finds[c[i]] != -1:
bit.update(finds[c[i]]+1, -1)
finds[c[i]] = i
bit.update(finds[c[i]]+1, 1)
for j, x in q[i]:
ans[j] = bit.query(i+1) - bit.query(x)
for a in ans:
print(a)
| 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(self, i):
v = 0
while i:
v = self.op(self.tree[i], v)
i -= i & -i
return v
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
q = [[] for _ in range(N+1)]
for i in range(Q):
x, y = list(map(int, input().split()))
q[y-1].append([i, x-1])
bit = BIT(N, add, 0)
finds = [-1]*(N+1)
ans = [0]*Q
for i in range(N):
if finds[c[i]] != -1:
bit.update(finds[c[i]]+1, -1)
finds[c[i]] = i
bit.update(finds[c[i]]+1, 1)
for j, x in q[i]:
ans[j] = bit.query(i+1) - bit.query(x)
for a in ans:
print(a)
| 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 & -i
def query(self, i):
v = self.ie
while i:
v = self.op(self.tree[i], v)
i -= i & -i
return v
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
q = [[] for _ in range(N+1)]
for i in range(Q):
x, y = list(map(int, input().split()))
q[y-1].append([i, x-1])
bit = BIT(N, add, 0)
finds = [-1]*(N+1)
ans = [0]*Q
for i in range(N):
if finds[c[i]] != -1:
bit.update(finds[c[i]]+1, -1)
finds[c[i]] = i
bit.update(finds[c[i]]+1, 1)
for j, x in q[i]:
ans[j] = bit.query(i+1) - bit.query(x)
for a in ans:
print(a)
| 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[0]), reverse=True)
C1 = [[-1, []] for i in range(N)]
rx = D[0][1]
for i, ci in zip(range(rx), C):
x = C1[ci-1]
x[1].append(x[0])
x[0] = i
C2 = C1[:]
C2.sort()
ans = [0] * Q
rj = rx
for li, ri, i in D:
if ri < rj:
for j in reversed(range(ri, rj)):
cj = C[j] - 1
x = C1[cj]
x[0] = x[1].pop()
C2.sort()
rj = ri
k = bisect(C2, [li-1,])
ans[i] = N - k
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| #!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
Ac = [0] * Q
for i in range(Q):
l, r = next(it)-1, next(it)-1
Aq[i] = r<<X | i
Ac[i] = l
Aq.sort()
dp = [0] * N
N1 = (2*N+1)//2
dp2 = [0] * (N1*2)
ans = [0] * Q
offset = 0
for arg in Aq:
r = arg >> X
i = arg & b1
for j in range(offset, r+1):
ci = Aa[j]
lo = N1 + dp[ci]
hi = N1 + j
while lo < hi:
if lo & 1:
dp2[lo] += 1
lo += 1
if not hi & 1:
dp2[hi] += 1
hi -= 1
lo >>= 1; hi >>= 1;
if lo == hi: dp2[lo] += 1
dp[ci] = j + 1
offset = r+1
l = Ac[i]
num = 0
j = l + N1
while j > 0:
num += dp2[j]
j >>= 1
ans[i] = num
print(*ans, sep="\n")
if __name__ == "__main__":
resolve()
| 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 range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class Segtree():
def __init__(self, aa):
self.inf = 0
self.n = n = len(aa)
self.tree_width = tree_width = 1 << (n - 1).bit_length()
self.tree = [-self.inf] * (tree_width * 2 - 1)
self.tree[tree_width-1:tree_width-1+n]=aa
for u in range(tree_width - 2, -1, -1):
self.tree[u] = self.tree[u * 2 + 1]+self.tree[u * 2 + 2]
def add(self, i, a):
seg_i = self.tree_width - 1 + i
self.tree[seg_i] += a
while seg_i != 0:
seg_i = (seg_i - 1) // 2
self.tree[seg_i] = self.tree[seg_i * 2 + 1]+self.tree[seg_i * 2 + 2]
def element(self, i):
return self.tree[self.tree_width - 1 + i]
# [l,r)の最大値
def sum(self, l, r, seg_i=0, segL=0, segR=-1):
if segR == -1: segR = self.tree_width
if r <= segL or segR <= l: return 0
if l <= segL and segR <= r: return self.tree[seg_i]
segM = (segL + segR) // 2
ret0 = self.sum(l, r, seg_i * 2 + 1, segL, segM)
ret1 = self.sum(l, r, seg_i * 2 + 2, segM, segR)
return ret0+ret1
n,q=MI()
cc=LI()
lri=[]
mx=500005
#mx=10
for i in range(q):
l,r=MI()
l-=1
lri.append((l,r,i))
lri.sort(key=lambda x:x[1])
#print(lri)
last=[-1]*mx
st=Segtree([0]*mx)
ans=[0]*q
now=0
for l,r,i in lri:
for j in range(now,r):
c=cc[j]
pre=last[c]
if pre!=-1:st.add(pre,-1)
last[c]=j
st.add(j,1)
#print(l,r,st.tree,last)
now=r
ans[i]=st.sum(l,r)
print(*ans,sep="\n")
| 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 range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class BitSum:
def __init__(self, n):
self.n = n + 1
self.table = [0] * self.n
def add(self, i, x):
i += 1
while i < self.n:
self.table[i] += x
i += i & -i
def sum(self, i):
i += 1
res = 0
while i > 0:
res += self.table[i]
i -= i & -i
return res
n,q=MI()
cc=LI()
lri=[]
mx=500005
#mx=10
for i in range(q):
l,r=MI()
l-=1
lri.append((l,r-1,i))
lri.sort(key=lambda x:x[1])
#print(lri)
last=[-1]*mx
st=BitSum(mx)
ans=[0]*q
now=0
for l,r,i in lri:
for j in range(now,r+1):
c=cc[j]
pre=last[c]
if pre!=-1:st.add(pre,-1)
last[c]=j
st.add(j,1)
#print(l,r,st.tree,last)
now=r+1
ans[i]=st.sum(r)-st.sum(l-1)
print(*ans,sep="\n")
| 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:
s += self.tree[i]
i = (i & (i + 1) )- 1
return s
def built(self, array):
""" array を初期値とするBITを構築 """
for i, a in enumerate(array):
self.add(i, a)
def add(self, i, x):
""" i 番目の要素に x を足す """
self.elem[i] += x
while i < self.n:
self.tree[i] += x
i |= i + 1
def get(self, i, j=None):
""" 部分区間和 [i, j) """
if j is None:
return self.elem[i]
if i == 0:
return self.sum(j)
return self.sum(j) - self.sum(i)
def lower_bound(self, x, equal=False):
""" (a0+a1+...+ai < x となる最大の i, その時の a0+a1+...+ai )
a0+a1+...+ai <= x としたい場合は equal = True
二分探索であるため、ai>=0 を満たす必要がある"""
sum_ = 0
pos = -1 # 1-indexed の時は pos = 0
if not equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] < x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
if equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] <= x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
return pos, sum_
def __getitem__(self, s):
""" [a0, a1, a2, ...] """
return self.elem[s]
def __iter__(self):
""" [a0, a1, a2, ...] """
for s in self.elem[:self.n]:
yield s
def __str__(self):
text1 = " ".join(["element: "] + list(map(str, self)))
text2 = " ".join(["cumsum(1-indexed): "] + list(str(self.sum(i)) for i in range(1, self.n + 1)))
return "\n".join((text1, text2))
class RangeSet:
""" 与えられた数列の区間内の種類数を求める """
def __init__(self, n, array, query):
"""
:param n: 要素数
:param array: 整数で種類付けされた数列
"""
self.n = n
self.BIT = Bit(self.n)
self.lastAppeared = [-1]*(self.n + 1)
self.array = []
self.query = []
for i, c in enumerate(array):
self.array.append(c)
self.lastAppeared[c] = i
for i, lr in enumerate(query):
l, r = lr
l -= 1
r -= 1
self.query.append((l,r,i))
self.query.sort(key=lambda x: x[1])
for x in self.lastAppeared:
if x != -1:
self.BIT.add(x, 1)
def solve(self):
res = [0] * len(self.query)
r0 = 0
for l, r, i in self.query:
for R in range(r0, r + 1):
self.BIT.add(self.lastAppeared[self.array[R]], -1)
self.lastAppeared[self.array[R]] = R
self.BIT.add(R, 1)
res[i] = self.BIT.get(l, r + 1)
r0 = r
return res
##############################################################################################
N, Q = map(int, input().split())
C = list(map(int, input().split()))
query = []
for i in range(Q):
l, r = map(int, input().split())
query.append((l,r))
RS = RangeSet(N, C, query)
res = RS.solve()
print(*res, sep="\n")
| 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
while i >= 0:
s += self.tree[i]
i = (i & (i + 1) )- 1
return s
def built(self, array):
""" array を初期値とするBITを構築 """
for i, a in enumerate(array):
self.add(i, a)
def add(self, i, x):
""" i 番目の要素に x を足す """
while i < self.n:
self.tree[i] += x
i |= i + 1
def get(self, i, j):
""" 部分区間和 [i, j) """
if i == 0:
return self.sum(j)
return self.sum(j) - self.sum(i)
def lower_bound(self, x, equal=False):
""" (a0+a1+...+ai < x となる最大の i, その時の a0+a1+...+ai )
a0+a1+...+ai <= x としたい場合は equal = True
二分探索であるため、ai>=0 を満たす必要がある"""
sum_ = 0
pos = -1 # 1-indexed の時は pos = 0
if not equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] < x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
if equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] <= x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
return pos, sum_
def __getitem__(self, i):
""" [a0, a1, a2, ...] """
return self.get(i, i+1)
def __iter__(self):
""" [a0, a1, a2, ...] """
for i in range(self.n):
yield self.get(i, i+1)
def __str__(self):
text1 = " ".join(["element: "] + list(map(str, self)))
text2 = " ".join(["cumsum(1-indexed): "] + list(str(self.sum(i)) for i in range(1, self.n + 1)))
return "\n".join((text1, text2))
class RangeSet:
""" 与えられた数列の区間内の種類数を求める """
def __init__(self, n, array, query):
"""
:param n: 要素数
:param array: 整数で種類付けされた数列
"""
self.n = n
self.BIT = Bit(self.n)
self.lastAppeared = [-1]*(self.n + 1)
self.array = []
self.query = []
for i, c in enumerate(array):
self.array.append(c)
self.lastAppeared[c] = i
for i, lr in enumerate(query):
l, r = lr
l -= 1
r -= 1
self.query.append((l,r,i))
self.query.sort(key=lambda x: x[1])
for x in self.lastAppeared:
if x != -1:
self.BIT.add(x, 1)
def solve(self):
res = [0] * len(self.query)
r0 = 0
for l, r, i in self.query:
for R in range(r0, r + 1):
self.BIT.add(self.lastAppeared[self.array[R]], -1)
self.lastAppeared[self.array[R]] = R
self.BIT.add(R, 1)
res[i] = self.BIT.get(l, r + 1)
r0 = r
return res
##############################################################################################
N, Q = map(int, input().split())
C = list(map(int, input().split()))
query = []
for i in range(Q):
l, r = map(int, input().split())
query.append((l,r))
RS = RangeSet(N, C, query)
res = RS.solve()
print(*res, sep="\n")
| 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
while i >= 0:
s += self.tree[i]
i = (i & (i + 1) )- 1
return s
def built(self, array):
""" array を初期値とするBITを構築 """
for i, a in enumerate(array):
self.add(i, a)
def add(self, i, x):
""" i 番目の要素に x を足す """
while i < self.n:
self.tree[i] += x
i |= i + 1
def get(self, i, j):
""" 部分区間和 [i, j) """
if i == 0:
return self.sum(j)
return self.sum(j) - self.sum(i)
def lower_bound(self, x, equal=False):
""" (a0+a1+...+ai < x となる最大の i, その時の a0+a1+...+ai )
a0+a1+...+ai <= x としたい場合は equal = True
二分探索であるため、ai>=0 を満たす必要がある"""
sum_ = 0
pos = -1 # 1-indexed の時は pos = 0
if not equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] < x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
if equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k < self.n and sum_ + self.tree[k] <= x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
return pos, sum_
def __getitem__(self, i):
""" [a0, a1, a2, ...] """
return self.get(i, i+1)
def __iter__(self):
""" [a0, a1, a2, ...] """
for i in range(self.n):
yield self.get(i, i+1)
def __str__(self):
text1 = " ".join(["element: "] + list(map(str, self)))
text2 = " ".join(["cumsum(1-indexed): "] + list(str(self.sum(i)) for i in range(1, self.n + 1)))
return "\n".join((text1, text2))
class RangeSet:
""" 与えられた数列の区間内の種類数を求める """
def __init__(self, n, array, query):
"""
:param n: 要素数
:param array: 整数で種類付けされた数列
"""
self.n = n
self.BIT = Bit(self.n)
self.lastAppeared = [-1]*(self.n + 1)
self.array = []
self.query = []
for i, c in enumerate(array):
self.array.append(c)
self.lastAppeared[c] = i
for i, lr in enumerate(query):
l, r = lr
l -= 1
r -= 1
self.query.append((l,r,i))
self.query.sort(key=lambda x: x[1])
for x in self.lastAppeared:
if x != -1:
self.BIT.add(x, 1)
def solve(self):
res = [0] * len(self.query)
r0 = 0
for l, r, i in self.query:
for R in range(r0, r + 1):
self.BIT.add(self.lastAppeared[self.array[R]], -1)
self.lastAppeared[self.array[R]] = R
self.BIT.add(R, 1)
res[i] = self.BIT.get(l, r + 1)
r0 = r
return res
##############################################################################################
N, Q = map(int, input().split())
C = list(map(int, input().split()))
query = []
for i in range(Q):
l, r = map(int, input().split())
query.append((l,r))
RS = RangeSet(N, C, query)
res = RS.solve()
print(*res, sep="\n")
| 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:
s += self.tree[i]
i -= i & -i
return s
def built(self, array):
""" array を初期値とするBITを構築 """
for i, a in enumerate(array, start=1):
self.add(i, a)
def add(self, i, x):
""" i 番目の要素に x を足す """
i += 1
while i <= self.n:
self.tree[i] += x
i += i & -i
def get(self, i, j):
""" 部分区間和 [i, j) """
if i == 0:
return self.sum(j)
return self.sum(j) - self.sum(i)
def lower_bound(self, x, equal=False):
""" (a0+a1+...+ai < x となる最大の i, その時の a0+a1+...+ai )
a0+a1+...+ai <= x としたい場合は equal = True
二分探索であるため、ai>=0 を満たす必要がある"""
sum_ = 0
pos = 0 # 1-indexed の時は pos = 0
if not equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k <= self.n and sum_ + self.tree[k] < x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
if equal:
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k <= self.n and sum_ + self.tree[k] <= x: # 1-indexed の時は k <= self.n
sum_ += self.tree[k]
pos += 1 << i
return pos-1, sum_
def __getitem__(self, i):
""" [a0, a1, a2, ...] """
return self.get(i, i+1)
def __iter__(self):
""" [a0, a1, a2, ...] """
for i in range(self.n):
yield self.get(i, i+1)
def __str__(self):
text1 = " ".join(["element: "] + list(map(str, self)))
text2 = " ".join(["cumsum(1-indexed): "] + list(str(self.sum(i)) for i in range(1, self.n + 1)))
return "\n".join((text1, text2))
class RangeSet:
""" 与えられた数列の区間内の種類数を求める """
def __init__(self, n, array, query):
"""
:param n: 要素数
:param array: 整数で種類付けされた数列
"""
self.n = n
self.BIT = Bit(self.n)
self.lastAppeared = [-1]*(self.n + 1)
self.array = []
self.query = []
for i, c in enumerate(array):
self.array.append(c)
self.lastAppeared[c] = i
for i, lr in enumerate(query):
l, r = lr
l -= 1
r -= 1
self.query.append((l,r,i))
self.query.sort(key=lambda x: x[1])
for x in self.lastAppeared:
if x != -1:
self.BIT.add(x, 1)
def solve(self):
res = [0] * len(self.query)
r0 = 0
for l, r, i in self.query:
for R in range(r0, r + 1):
self.BIT.add(self.lastAppeared[self.array[R]], -1)
self.lastAppeared[self.array[R]] = R
self.BIT.add(R, 1)
res[i] = self.BIT.get(l, r + 1)
r0 = r
return res
##############################################################################################
N, Q = map(int, input().split())
C = list(map(int, input().split()))
query = []
for i in range(Q):
l, r = map(int, input().split())
query.append((l,r))
RS = RangeSet(N, C, query)
res = RS.solve()
print(*res, sep="\n")
# A = [2,3,4,6,7,11,13,14]
# B = Bit(8)
# B.built(A)
# print(list(B.get(i,i+1) for i in range(len(A))))
# print(B)
# print(B.sum(3))
# print(B.get(3,6))
# print(list(B.lower_bound(i) for i in range(64)))
| 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):
self.init_val = init_val
self.size = N
self.L = [init_val]*(N+1)
def sum(self, r):
"""
sum[,r)
calc sum from L[0] to L[r-1]
"""
ret = self.init_val
while r > 0:
ret += self.L[r]
r -= r & (-r)
return ret
def range_sum(self, l, r):
"""
idx周りが怪しい?
sum[l,r)
calc sum from L[l] to L[r-1]
"""
return self.sum(r-1)-self.sum(l-1)
def add(self, i, x):
"""
L[i] += x
"""
#while i < self.size:
while i <= self.size:
self.L[i] += x
i += i & (-i)
def bisect(self,k:float)->int:
""" binary search on BIT
get index x s.t self.sum(,)>=k
RETURN:
res:index of x
"""
k+=1 #convert k into 1-index
res=0
N=1
while N<self.size:
N*=2
i=N//2
while i>0:
if(res+i<self.size and self.L[res+i]<k): #move to rignt on tree
k-=self.L[res+i]
res+=i
#else move to left
i//=2
return res+1
N,Q = list(map(int,input().split()))
C=[None]
for c in list(map(int,input().split())):
C.append(c)
pos=[list([int(x) for x in input().split()]) for i in range(Q)]
pos = sorted([[l,r,i] for i,(l,r) in enumerate(pos)],key=lambda x:x[1])
last_appeared=defaultdict(int)
B = BIT(N,0)
ans=[-1]*Q
cur_r=1
for l,r,i in pos:
while cur_r<=r:
last = last_appeared[C[cur_r]]
if last==0:#first add
B.add(cur_r,1)
else:
B.add(last,-1)
B.add(cur_r,1)
last_appeared[C[cur_r]]=cur_r #lastの更新
cur_r+=1
assert l>=1
ans[i]=B.sum(r)-B.sum(l-1)
print(("\n".join(map(str,ans))))
| 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):
self.init_val = init_val
self.size = N
self.L = [init_val]*(N+1)
def sum(self, r):
"""
sum[,r)
calc sum from L[0] to L[r-1]
"""
ret = self.init_val
while r > 0:
ret += self.L[r]
r -= r & (-r)
return ret
def range_sum(self, l, r):
"""
idx周りが怪しい?
sum[l,r)
calc sum from L[l] to L[r-1]
"""
return self.sum(r-1)-self.sum(l-1)
def add(self, i, x):
"""
L[i] += x
"""
while i <= self.size:
self.L[i] += x
i += i & (-i)
def bisect(self,k:float)->int:
""" binary search on BIT
get index x s.t self.sum(,)>=k
RETURN:
res:index of x
"""
k+=1 #convert k into 1-index
res=0
N=1
while N<self.size:
N*=2
i=N//2
while i>0:
if(res+i<self.size and self.L[res+i]<k): #move to rignt on tree
k-=self.L[res+i]
res+=i
#else move to left
i//=2
return res+1
N,Q = list(map(int,input().split()))
C=list(map(int,input().split()))
pos=[]
for i in range(Q):
l,r = list(map(int,input().split()))
pos.append((l,r,i))
pos=sorted(pos,key=lambda x:x[1])
last_appeared=defaultdict(int)
B = BIT(N,0)
ans=[-1]*Q
cur_r=1
for l,r,i in pos:
while cur_r<=r:
last = last_appeared[C[cur_r-1]]
if last==0:#first add
B.add(cur_r,1)
else:
B.add(last,-1)
B.add(cur_r,1)
last_appeared[C[cur_r-1]]=cur_r #lastの更新
cur_r+=1
assert l>=1
ans[i]=B.sum(r)-B.sum(l-1)
print(("\n".join(map(str,ans))))
| 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):
self.init_val = init_val
self.size = N
self.L = [init_val]*(N+1)
def sum(self, r):
"""
sum[,r)
calc sum from L[0] to L[r-1]
"""
ret = self.init_val
while r > 0:
ret += self.L[r]
r -= r & (-r)
return ret
def range_sum(self, l, r):
"""
idx周りが怪しい?
sum[l,r)
calc sum from L[l] to L[r-1]
"""
return self.sum(r-1)-self.sum(l-1)
def add(self, i, x):
"""
L[i] += x
"""
while i <= self.size:
self.L[i] += x
i += i & (-i)
def bisect(self,k:float)->int:
""" binary search on BIT
get index x s.t self.sum(,)>=k
RETURN:
res:index of x
"""
k+=1 #convert k into 1-index
res=0
N=1
while N<self.size:
N*=2
i=N//2
while i>0:
if(res+i<self.size and self.L[res+i]<k): #move to rignt on tree
k-=self.L[res+i]
res+=i
#else move to left
i//=2
return res+1
N,Q = list(map(int,input().split()))
C=list(map(int,input().split()))
pos=[]
for i in range(Q):
l,r = list(map(int,input().split()))
pos.append((l,r,i))
pos=sorted(pos,key=lambda x:x[1])
last_appeared=defaultdict(int)
B = BIT(N,0)
ans=[-1]*Q
cur_r=1
for l,r,i in pos:
while cur_r<=r:
last = last_appeared[C[cur_r-1]]
if last==0:#first add
B.add(cur_r,1)
else:
B.add(last,-1)
B.add(cur_r,1)
last_appeared[C[cur_r-1]]=cur_r #lastの更新
cur_r+=1
assert l>=1
ans[i]=B.sum(r)-B.sum(l-1)
print(("\n".join(map(str,ans))))
| 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
self.size = N
self.L = [init_val]*(N+1)
def sum(self, r):
"""
sum[,r)
calc sum from L[0] to L[r-1]
"""
ret = self.init_val
while r > 0:
ret += self.L[r]
r -= r & (-r)
return ret
def range_sum(self, l, r):
"""
idx周りが怪しい?
sum[l,r)
calc sum from L[l] to L[r-1]
"""
return self.sum(r-1)-self.sum(l-1)
def add(self, i, x):
"""
L[i] += x
"""
while i <= self.size:
self.L[i] += x
i += i & (-i)
def bisect(self,k:float)->int:
""" binary search on BIT
get index x s.t self.sum(,)>=k
RETURN:
res:index of x
"""
k+=1 #convert k into 1-index
res=0
N=1
while N<self.size:
N*=2
i=N//2
while i>0:
if(res+i<self.size and self.L[res+i]<k): #move to rignt on tree
k-=self.L[res+i]
res+=i
#else move to left
i//=2
return res+1
N,Q = list(map(int,input().split()))
C=list(map(int,input().split()))
pos=[]
for i in range(Q):
l,r = list(map(int,input().split()))
pos.append([l,r,i])
pos=sorted(pos,key=lambda x:x[1])
last_appeared=[0]*(N+1)
B = BIT(N,0)
ans=[-1]*Q
cur_r=1
for l,r,i in pos:
while cur_r<=r:
last = last_appeared[C[cur_r-1]]
if last==0:#first add
B.add(cur_r,1)
else:
B.add(last,-1)
B.add(cur_r,1)
last_appeared[C[cur_r-1]]=cur_r #lastの更新
cur_r+=1
assert l>=1
ans[i]=B.sum(r)-B.sum(l-1)
print(("\n".join(map(str,ans))))
| 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] * self.tree_size
self.no_effect = no_effect
self.initialize_tree(target, no_effect)
@classmethod
def initialize_func(cls, value):
return 1 << value
@classmethod
def merge_func(cls, a, b):
return a | b
def merge_child_data(self, node):
child1 = node * 2 + 1
child2 = node * 2 + 2
merged = self.merge_func(self.tree[child1], self.tree[child2])
return merged
def initialize_tree(self, target: list, no_effect=0):
initial_leaf = self.tree_size // 2
leaves = list(range(initial_leaf, initial_leaf+len(target)))
for value, leaf in zip(target, leaves):
self.tree[leaf] = self.initialize_func(value)
for parent in range(initial_leaf-1, -1, -1):
self.tree[parent] = self.merge_child_data(parent)
def update(self, new_value, index):
leaf = self.tree_size//2 + index
new_data = self.initialize_func(new_value)
if self.tree[leaf] == new_data:
return
self.tree[leaf] = new_data
parent = (leaf-1) // 2
while parent >= 0:
new_data = self.merge_child_data(parent)
if self.tree[parent] == new_data:
break
self.tree[parent] = new_data
parent = (parent-1) // 2
def resolve_query(self, from_, to):
result = self.no_effect
left, right = from_ + self.tree_size // 2, to + self.tree_size // 2
while left <= right:
result = self.merge_func(result, self.tree[left])
result = self.merge_func(result, self.tree[right])
left //= 2
right = right//2 - 1
return bin(result).count('1')
def main():
n, q = list(map(int, input().split()))
C = list(map(int, input().split()))
seg_tree = SegmentTree(C)
for _ in range(q):
l, r = list(map(int, input().split()))
res = seg_tree.resolve_query(l-1, r-1)
print(res)
if __name__ == "__main__":
main()
| 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_effect] * self.tree_size
self.no_effect = no_effect
self.initialize_tree(target, no_effect)
@classmethod
def initialize_func(cls, value):
return {value}
@classmethod
def merge_func(cls, a, b):
return a | b
def merge_child_data(self, node):
child1 = node * 2 + 1
child2 = node * 2 + 2
merged = self.merge_func(self.tree[child1], self.tree[child2])
return merged
def initialize_tree(self, target: list, no_effect=0):
initial_leaf = self.tree_size // 2
leaves = list(range(initial_leaf, initial_leaf+len(target)))
for value, leaf in zip(target, leaves):
self.tree[leaf] = self.initialize_func(value)
for parent in range(initial_leaf-1, -1, -1):
self.tree[parent] = self.merge_child_data(parent)
def update(self, new_value, index):
leaf = self.tree_size//2 + index
new_data = self.initialize_func(new_value)
if self.tree[leaf] == new_data:
return
self.tree[leaf] = new_data
parent = (leaf-1) // 2
while parent >= 0:
new_data = self.merge_child_data(parent)
if self.tree[parent] == new_data:
break
self.tree[parent] = new_data
parent = (parent-1) // 2
def resolve_query(self, from_, to):
result = self.no_effect
left, right = from_ + self.tree_size // 2, to + self.tree_size // 2
while left <= right:
result = self.merge_func(result, self.tree[left])
result = self.merge_func(result, self.tree[right])
left //= 2
right = right//2 - 1
return len(result)
def main():
n, q = list(map(int, input().split()))
C = list(map(int, input().split()))
seg_tree = SegmentTree(C)
for _ in range(q):
l, r = list(map(int, input().split()))
res = seg_tree.resolve_query(l-1, r-1)
print(res)
if __name__ == "__main__":
main()
| 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:
ret += self.bit[x]
x -= x & -x
return ret
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
rl = [None] * Q
for i in range(Q):
l, r = list(map(int, input().split()))
rl[i] = (r, l, i)
rl.sort()
bit = BIT(N+1)
ans = [None] * Q
last_idx = [-1] * (N+1)
j = 0
for r, l, i in rl:
while j < r:
if last_idx[c[j]] == -1:
last_idx[c[j]] = j
else:
bit.add(last_idx[c[j]]+1, -1)
last_idx[c[j]] = j
bit.add(j+1, 1)
j += 1
ans[i] = bit.sum(r) - bit.sum(l-1)
for a in ans:
print(a)
| 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 = [None] * Q
for i in range(Q):
l, r = map(int, input().split())
rl[i] = (r, l, i)
rl.sort()
ans = [None] * Q
last_idx = [-1] * (N+1)
j = 0
for r, l, i in rl:
while j < r:
if last_idx[c[j]] == -1:
last_idx[c[j]] = j
else:
add(last_idx[c[j]]+1, -1)
last_idx[c[j]] = j
add(j+1, 1)
j += 1
ans[i] = sum(r) - sum(l-1)
print(*ans, sep='\n')
| 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 -= x & -x
return ret
c = list(map(int, input().split()))
rl = [None] * Q
for i in range(Q):
l, r = list(map(int, input().split()))
rl[i] = (r, l, i)
rl.sort()
ans = [None] * Q
last_idx = [-1] * (N+1)
j = 0
for r, l, i in rl:
while j < r:
if last_idx[c[j]] == -1:
last_idx[c[j]] = j
else:
add(last_idx[c[j]]+1, -1)
last_idx[c[j]] = j
add(j+1, 1)
j += 1
ans[i] = sum(r) - sum(l-1)
for a in ans:
print(a)
if __name__ == "__main__":
main() | 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 -= x & -x
return ret
c = list(map(int, input().split()))
lr = [None] * Q
for i in range(Q):
l, r = list(map(int, input().split()))
lr[i] = (i, l, r)
lr.sort(key=lambda x: x[2])
ans = [None] * Q
last_idx = [-1] * (N+1)
j = 0
for i, l, r in lr:
while j < r:
if last_idx[c[j]] == -1:
last_idx[c[j]] = j
else:
add(last_idx[c[j]]+1, -1)
last_idx[c[j]] = j
add(j+1, 1)
j += 1
ans[i] = sum(r) - sum(l-1)
for a in ans:
print(a)
if __name__ == "__main__":
main() | 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):
while i <= self.size:
self.tree[i] += x
i += i & -i
n, q = map(int, input().split())
c = list(map(int, input().split()))
rli = []
for i in range(q):
l, r = map(int, input().split())
rli.append((r, l, i))
rli.sort()
last = [-1 for _ in range(n + 1)]
bit = Bit(n)
ans = [-1 for _ in range(q)]
cur = 1
for r, l, i in rli:
for j in range(cur, r + 1):
if last[c[j - 1]] != -1:
bit.add(last[c[j - 1]], -1)
last[c[j - 1]] = j
bit.add(j, 1)
cur = r + 1
ans[i] = bit.sum(r) - bit.sum(l - 1)
print(*ans, sep="\n")
| 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):
while i <= self.size:
self.tree[i] += x
i += i & -i
n, q = map(int, input().split())
c = list(map(int, input().split()))
rli = []
for i in range(q):
l, r = map(int, input().split())
rli.append((r, l, i))
rli.sort(key=lambda x: x[0])
last = [-1 for _ in range(n + 1)]
bit = Bit(n)
ans = [-1 for _ in range(q)]
cur = 1
for r, l, i in rli:
for j in range(cur, r + 1):
if last[c[j - 1]] != -1:
bit.add(last[c[j - 1]], -1)
last[c[j - 1]] = j
bit.add(j, 1)
cur = r + 1
ans[i] = bit.sum(r) - bit.sum(l - 1)
print(*ans, sep="\n")
| 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(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n):
res = [None] * n
for i in range(n):
res[i] = II()
return res
def LIR(n):
res = [None] * n
for i in range(n):
res[i] = LI_() + [i]
return res
def FR(n):
res = [None] * n
for i in range(n):
res[i] = IF()
return res
mod = 1000000007
inf = float('INF')
#solve
def solve():
n, q = LI()
c = LI()
lr = LIR(q)
ans = [None] * q
lr.sort(key=lambda x: x[1])
dp = [-1] * (max(c) + 1)
bit = [0] * (n + 1)
def add(i, w):
"""
i番目にwを加える
:param int i:
:param int w:
:return:
"""
x = i + 1
while x <= n:
bit[x - 1] += w
x += x & -x
return
def sum(i):
"""
[0,i]の合計
:param int i:
:return:
"""
res = 0
x = i + 1
while x > 0:
res += bit[x - 1]
x -= x & -x
return res
t = 0
def f(t):
l, r, j = lr[t]
xr = sum(r)
xl = sum(l-1)
tmp = xr - xl
ans[j] = tmp
for i in range(n):
ci = c[i]
l = dp[ci]
add(i, 1)
dp[ci] = i
if l != -1:
add(l, -1)
while t < q and lr[t][1] <= i:
f(t)
t += 1
if t == q:
break
for ai in ans:
print(ai)
return
#main
if __name__ == '__main__':
solve()
| #!/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
for i in range(n):
l, r = list(map(int, input().split()))
res[i] = (l-1, r-1, i)
return res
#solve
def solve():
n, q = LI()
c = LI()
lr = LIR(q)
ans = [None] * q
lr.sort(key=lambda x: x[1])
dp = [-1] * (max(c) + 1)
bit = [0] * (n + 1)
def add(i, w):
"""
i番目にwを加える
:param int i:
:param int w:
:return:
"""
x = i + 1
while x <= n:
bit[x - 1] += w
x += x & -x
return
def sum(i):
"""
[0,i]の合計
:param int i:
:return:
"""
res = 0
x = i + 1
while x > 0:
res += bit[x - 1]
x -= x & -x
return res
t = 0
def f(t):
l, r, j = lr[t]
xr = sum(r)
xl = sum(l-1)
tmp = xr - xl
ans[j] = tmp
for i in range(n):
ci = c[i]
l = dp[ci]
add(i, 1)
dp[ci] = i
if l != -1:
add(l, -1)
while t < q and lr[t][1]<= i:
f(t)
t += 1
if t == q:
break
for ai in ans:
print(ai)
return
#main
if __name__ == '__main__':
solve()
| 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.bit[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += i & -i
query = []
for i in range(q):
l, r = list(map(int, input().split()))
query.append((r, l, i))
query.sort()
appear = [-1]*(n+2)
bit = BIT(n)
right = 0
ans = [None]*(q)
for x in range(q):
r, l, z = query[x]
for i in range(right, r):
if appear[c[i]] != -1:
bit.add(appear[c[i]]+1, -1)
appear[c[i]] = i
bit.add(appear[c[i]]+1, 1)
right = r
ans[z] = bit.sum(r) - bit.sum(l-1)
for i in range(q):
print((ans[i]))
| 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]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += i & -i
query = [list(map(int, input().split()))+[i] for i in range(q)]
query.sort(key = lambda x: x[1])
appear = [-1]*(n+2)
bit = BIT(n)
right = 0
ans = [None]*(q)
for l, r, z in query:
for i in range(right, r):
num = appear[c[i]]
if num != -1:
bit.add(num+1, -1)
appear[c[i]] = i
bit.add(i+1, 1)
right = r
ans[z] = bit.sum(r) - bit.sum(l-1)
print(*ans, sep="\n")
| 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):
result = 0
while (index > 0):
result += self.bit[index]
index -= index & -index
return result
def bit_sum_range(self, l, r):
if (l == r):
return 1
else:
return self.bit_sum(r) - self.bit_sum(l - 1)
def main():
from sys import stdin
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
readline = stdin.readline
query = [list(map(int, readline().split())) + [i] for i in range(Q)]
query_result = [0 for i in range(Q)]
collar_pos = [-1] * (N + 1)
bit = BinaryIndexedTree(N)
sorted_query = sorted(query, key=lambda query: query[1])
index = 1
for query in sorted_query:
while (index <= query[1]):
# update BIT
if (collar_pos[c[index-1]] != -1):
bit.bit_add(collar_pos[c[index-1]], -1)
bit.bit_add(index, 1)
# update collar_pos
collar_pos[c[index-1]] = index
index += 1
query_result[query[2]] = bit.bit_sum_range(query[0], query[1])
print(*query_result, sep='\n')
if __name__ == '__main__':
main()
| 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):
result = 0
while (index > 0):
result += self.bit[index]
index -= index & -index
return result
def bit_sum_range(self, l, r):
if (l == r):
return 1
else:
return self.bit_sum(r) - self.bit_sum(l - 1)
def main():
from sys import stdin
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
readline = stdin.readline
query = [list(map(int, readline().split())) + [i] for i in range(Q)]
query_result = [0 for i in range(Q)]
collar_pos = [-1] * (N + 1)
bit = BinaryIndexedTree(N)
sorted_query = sorted(query, key=lambda query: query[1])
index = 1
for query in sorted_query:
l, r, q = query
while (index <= r):
# update BIT
if (collar_pos[c[index-1]] != -1):
bit.bit_add(collar_pos[c[index-1]], -1)
bit.bit_add(index, 1)
# update collar_pos
collar_pos[c[index-1]] = index
index += 1
query_result[q] = bit.bit_sum_range(l, r)
print(*query_result, sep='\n')
if __name__ == '__main__':
main()
| 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):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._tree = tree
self._dot = dot
self._unit = unit
def __getitem__(self, i):
return self._tree[i + self._n]
def update(self, i, v):
i += self._n
self._tree[i] = v
while i != 1:
i >>= 1
self._tree[i] = self._dot(self._tree[i << 1], self._tree[i << 1 | 1])
def add(self, i, v):
self.update(i, self[i] + v)
def sum(self, l, r):
l += self._n
r += self._n
l_val = r_val = self._unit
while l < r:
if l & 1:
l_val = self._dot(l_val, self._tree[l])
l += 1
if r & 1:
r -= 1
r_val = self._dot(self._tree[r], r_val)
l >>= 1
r >>= 1
return self._dot(l_val, r_val)
from operator import add
def resolve():
n, q = map(int, input().split())
C = list(map(lambda x : int(x) - 1, input().split()))
# build segment tree
A = [0] * n
used = set()
for i, c in enumerate(C):
if c in used:
continue
A[i] += 1
used.add(c)
tree = SegmentTree(A, add, 0)
# caluculate next
next = [-1] * n
col_to_idx = {}
for i in range(n - 1, -1, -1):
c = C[i]
if c in col_to_idx:
next[i] = col_to_idx[c]
col_to_idx[c] = i
# process queries
queries = [None] * q
for i in range(q):
l, r = map(int, input().split())
l -= 1
queries[i] = (l, r, i)
queries.sort(reverse = 1)
ans = [0] * q
for l, c in enumerate(C):
while queries and queries[-1][0] == l:
l, r, i = queries.pop()
ans[i] = tree.sum(l, r)
if next[l] != -1:
tree.add(next[l], 1)
tree.add(l, -1)
print(*ans, sep = '\n')
resolve()
| 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):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._tree = tree
self._dot = dot
self._unit = unit
def __getitem__(self, i):
return self._tree[i + self._n]
def update(self, i, v):
i += self._n
self._tree[i] = v
while i != 1:
i >>= 1
self._tree[i] = self._dot(self._tree[i << 1], self._tree[i << 1 | 1])
def add(self, i, v):
self.update(i, self[i] + v)
def sum(self, l, r):
l += self._n
r += self._n
l_val = r_val = self._unit
while l < r:
if l & 1:
l_val = self._dot(l_val, self._tree[l])
l += 1
if r & 1:
r -= 1
r_val = self._dot(self._tree[r], r_val)
l >>= 1
r >>= 1
return self._dot(l_val, r_val)
from operator import add
def resolve():
n, q = map(int, input().split())
C = list(map(lambda x : int(x) - 1, input().split()))
A = [0] * n
used = [0] * n
for i, c in enumerate(C):
if used[c]:
continue
used[c] = 1
A[i] = 1
tree = SegmentTree(A, add, 0)
next = [-1] * n
used = [-1] * n
for i in range(n - 1, -1, -1):
c = C[i]
if used[c] != -1:
next[i] = used[c]
used[c] = i
queries = [None] * q
for i in range(q):
l, r = map(int, input().split())
queries[i] = (l - 1, r, i)
queries.sort(reverse = 1)
ans = [0] * q
for l in range(n):
while queries and queries[-1][0] == l:
l, r, i = queries.pop()
ans[i] = tree.sum(l, r)
if next[l] != -1:
tree.add(next[l], 1)
print(*ans, sep = '\n')
resolve()
| 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,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def main():
n,q=MI()
c=LI()
for i in range(n):
c[i]={c[i]}
#####segfunc#####
def segfunc(x, y):
return x.union(y)
ide_ele =set()
S=SegTree(c,segfunc,ide_ele)
for _ in range(q):
ll,rr=MI()
print((len(S.query(ll-1,rr))))
if __name__ == "__main__":
main()
| 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()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
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)
def main():
n,q=MI()
C=[0]+LI()
lr=[]
for i in range(q):
l,r=MI()
lr.append([l,r,i])
lr.sort(key=lambda x:x[1])
#print(lr)
R=[-1]*(n+1)
B=BIT(n)
now=1
ans=[-1]*(q)
for l,r,i in lr:
while now<=r:
if R[C[now]]!=-1:
B.add(R[C[now]],-1)
R[C[now]]=now
B.add(R[C[now]],1)
now+=1
#print(R)
#print(B.el)
ans[i]=B.get(l-1,r)
print(*ans,sep="\n")
if __name__ == "__main__":
main()
| 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 & -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
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 をたす。
>>> b = FenwickTree(5)
>>> b.add(0, 10)
>>> b.bit
[0, 10, 10, 0, 10, 0]
"""
if not 0 <= k < self.size:
raise IndexError(f"FenwickTree.add(): size is {self.size}. accessed [{k}]")
k += 1 # 1-index
while k <= self.size:
self.bit[k] += x
LSB = k & (-k)
k += LSB
def _accum_sum(self, k: int) -> Num:
""" (1-index, 内部関数) bit の 1 ~ k 番目の要素の和を求める。"""
s = 0
while k > 0:
s += self.bit[k]
LSB = k & (-k)
k -= LSB
return s
def sum(self, l: int, r: int) -> Num:
"""
(0-index で) [l, r) 区間の和を求める。
>>> b = FenwickTree(5)
>>> b.add(1, 10)
>>> b.add(2, 20)
>>> b.sum(1, 3)
30
"""
if not 0 <= l <= r <= self.size:
raise IndexError(f"FenwickTree.sum(): size is {self.size}. got slice is [{l}:{r}]")
# 0-index の数列における [l]...[r-1] の閉区間を計算。1-index なら [l+1]...[r]。
return self._accum_sum(r) - self._accum_sum(l)
def mi():
return list(map(int, input().split()))
def mi_0():
return [int(x)-1 for x in input().split()]
def solve(n, q, interval, query):
"""
[s, t] なる点を含むリスト interval
[l, r(, query-number)] (0-index) なるクエリを q 個含むリスト query。l <= s and t <= r なる点の個数は何個か？
"""
query_to_ans = [-1] * q
sorted_query = sorted(query, key=itemgetter(0))
sorted_interval = sorted(interval, key=itemgetter(0))
# ft = FenwickTree(5 * 10 ** 5 + 5)
b = BIT(5 * 10 ** 5 + 5)
# main
for l, r, query_num in reversed(sorted_query):
# l 以上のものを全て処理対象に入れる
while sorted_interval and l <= sorted_interval[-1][0]:
_, t = sorted_interval.pop()
# ft.add(t, 1)
b.add(t+1, 1)
# query_to_ans[query_num] = (r - l + 1) - ft.sum(0, r+1)
query_to_ans[query_num] = (r - l + 1) - b.sum(r+1)
# output
for ans in query_to_ans:
print(ans)
def main():
n, q = mi()
L = tuple(mi())
prev = dict()
intervals = []
for i in range(n):
if L[i] not in prev:
prev[L[i]] = i
else:
intervals.append((prev[L[i]], i))
prev[L[i]] = i
query = []
for i in range(q):
l, r = mi_0()
query.append((l, r, i))
solve(n, q, intervals, query)
if __name__ == '__main__':
main() | 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 をたす。
>>> b = FenwickTree(5)
>>> b.add(0, 10)
>>> b.bit
[0, 10, 10, 0, 10, 0]
"""
if not 0 <= k < self.size:
raise IndexError(f"FenwickTree.add(): size is {self.size}. accessed [{k}]")
k += 1 # 1-index
while k <= self.size:
self.bit[k] += x
LSB = k & (-k)
k += LSB
def _accum_sum(self, k: int) -> Num:
""" (1-index, 内部関数) bit の 1 ~ k 番目の要素の和を求める。"""
s = 0
while k > 0:
s += self.bit[k]
LSB = k & (-k)
k -= LSB
return s
def sum(self, l: int, r: int) -> Num:
"""
(0-index で) [l, r) 区間の和を求める。
>>> b = FenwickTree(5)
>>> b.add(1, 10)
>>> b.add(2, 20)
>>> b.sum(1, 3)
30
"""
if not 0 <= l <= r <= self.size:
raise IndexError(f"FenwickTree.sum(): size is {self.size}. got slice is [{l}:{r}]")
# 0-index の数列における [l]...[r-1] の閉区間を計算。1-index なら [l+1]...[r]。
return self._accum_sum(r) - self._accum_sum(l)
def input(): return sys.stdin.readline().rstrip()
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def solve(n, q, interval, query):
"""
[s, t] なる点を含むリスト interval
[l, r(, query-number)] (0-index) なるクエリを q 個含むリスト query。l <= s and t <= r なる点の個数は何個か？
"""
query_to_ans = [-1] * q
sorted_query = sorted(query, key=itemgetter(0))
sorted_interval = sorted(interval, key=itemgetter(0))
ft = FenwickTree(5 * 10 ** 5 + 5)
# main
for l, r, query_num in reversed(sorted_query):
# l 以上のものを全て処理対象に入れる
while sorted_interval and l <= sorted_interval[-1][0]:
_, t = sorted_interval.pop()
ft.add(t, 1)
query_to_ans[query_num] = (r - l + 1) - ft.sum(0, r+1)
# output
for ans in query_to_ans:
print(ans)
def main():
n, q = mi()
L = tuple(mi())
prev = dict()
intervals = []
for i in range(n):
if L[i] not in prev:
prev[L[i]] = i
else:
intervals.append((prev[L[i]], i))
prev[L[i]] = i
query = []
for i in range(q):
l, r = mi_0()
query.append((l, r, i))
solve(n, q, intervals, query)
if __name__ == '__main__':
main()
| 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 をたす。
>>> b = FenwickTree(5)
>>> b.add(0, 10)
>>> b.bit
[0, 10, 10, 0, 10, 0]
"""
if not 0 <= k < self.size:
raise IndexError(f"FenwickTree.add(): size is {self.size}. accessed [{k}]")
k += 1 # 1-index
while k <= self.size:
self.bit[k] += x
LSB = k & (-k)
k += LSB
def _accum_sum(self, k: int) -> Num:
""" (1-index, 内部関数) bit の 1 ~ k 番目の要素の和を求める。"""
s = 0
while k > 0:
s += self.bit[k]
LSB = k & (-k)
k -= LSB
return s
def sum(self, l: int, r: int) -> Num:
"""
(0-index で) [l, r) 区間の和を求める。
>>> b = FenwickTree(5)
>>> b.add(1, 10)
>>> b.add(2, 20)
>>> b.sum(1, 3)
30
"""
if not 0 <= l <= r <= self.size:
raise IndexError(f"FenwickTree.sum(): size is {self.size}. got slice is [{l}:{r}]")
# 0-index の数列における [l]...[r-1] の閉区間を計算。1-index なら [l+1]...[r]。
return self._accum_sum(r) - self._accum_sum(l)
def input(): return sys.stdin.readline().rstrip()
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def solve(n, q, interval, query):
"""
[s, t] なる点を含むリスト interval
[l, r(, query-number)] (0-index) なるクエリを q 個含むリスト query。l <= s and t <= r なる点の個数は何個か？
"""
query_to_ans = [-1] * q
sorted_query = sorted(query, key=itemgetter(0))
sorted_interval = sorted(interval, key=itemgetter(0))
ft = FenwickTree(5 * 10 ** 5 + 5)
# main
for l, r, query_num in reversed(sorted_query):
# l 以上のものを全て処理対象に入れる
while sorted_interval and l <= sorted_interval[-1][0]:
_, t = sorted_interval.pop()
ft.add(t, 1)
query_to_ans[query_num] = (r - l + 1) - ft.sum(0, r+1)
# output
for ans in query_to_ans:
print(ans)
def main():
n, q = mi()
L = tuple(mi())
prev = dict()
intervals = []
for i in range(n):
if L[i] not in prev:
prev[L[i]] = i
else:
intervals.append((prev[L[i]], i))
prev[L[i]] = i
query = []
for i in range(q):
l, r = mi_0()
query.append((l, r, i))
solve(n, q, intervals, query)
if __name__ == '__main__':
main()
| 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 をたす。
>>> b = FenwickTree(5)
>>> b.add(0, 10)
>>> b.bit
[0, 10, 10, 0, 10, 0]
"""
if not 0 <= k < self.size:
raise IndexError(f"FenwickTree.add(): size is {self.size}. accessed [{k}]")
k += 1 # 1-index
while k <= self.size:
self.bit[k] += x
LSB = k & (-k)
k += LSB
def _accum_sum(self, k: int) -> Num:
""" (1-index, 内部関数) bit の 1 ~ k 番目の要素の和を求める。"""
s = 0
while k > 0:
s += self.bit[k]
LSB = k & (-k)
k -= LSB
return s
def sum(self, l: int, r: int) -> Num:
"""
(0-index で) [l, r) 区間の和を求める。
>>> b = FenwickTree(5)
>>> b.add(1, 10)
>>> b.add(2, 20)
>>> b.sum(1, 3)
30
"""
if not 0 <= l <= r <= self.size:
raise IndexError(f"FenwickTree.sum(): size is {self.size}. got slice is [{l}:{r}]")
# 0-index の数列における [l]...[r-1] の閉区間を計算。1-index なら [l+1]...[r]。
return self._accum_sum(r) - self._accum_sum(l)
def input(): return sys.stdin.readline().rstrip()
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def solve(n, q, interval, query):
"""
[s, t] なる点を含むリスト interval
[l, r(, query-number)] (0-index) なるクエリを q 個含むリスト query。l <= s and t <= r なる点の個数は何個か？
"""
query_to_ans = [-1] * q
query.sort(key=itemgetter(0))
interval.sort(key=itemgetter(0))
ft = FenwickTree(5 * 10 ** 5 + 5)
# main
for l, r, query_num in reversed(query):
# l 以上のものを全て処理対象に入れる
while interval and l <= interval[-1][0]:
_, t = interval.pop()
ft.add(t, 1)
query_to_ans[query_num] = (r - l + 1) - ft.sum(0, r+1)
# output
for ans in query_to_ans:
print(ans)
def main():
n, q = mi()
L = tuple(mi())
prev = dict()
intervals = []
for i in range(n):
if L[i] not in prev:
prev[L[i]] = i
else:
intervals.append((prev[L[i]], i))
prev[L[i]] = i
query = []
for i in range(q):
l, r = mi_0()
query.append((l, r, i))
solve(n, q, intervals, query)
if __name__ == '__main__':
main()
| 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.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
# reffer to: https://qiita.com/dn6049949/items/afa12d5d079f518de368
class SegmentTree:
# 初期化処理
# f : SegmentTreeにのせるモノイド
# default : fに対する単位元
def __init__(self, size, f=lambda x,y : x+y, default=0):
self.size = 2**(size-1).bit_length() # 簡単のため要素数Nを2冪にする
self.default = default
self.data = [default for _ in range(self.size * 2)] # 要素を単位元で初期化
self.f = f
def update(self, i, x):
i += self.size
self.data[i] = x
while i > 0:
i >>= 1
self.data[i] = self.f(self.data[i*2], self.data[i*2+1])
def query(self, l, r):
l += self.size
r += self.size
lres, rres = self.default, self.default
while l < r:
if l & 1:
lres = self.f(lres, self.data[l])
l += 1
if r & 1:
r -= 1
rres = self.f(self.data[r], rres) # モノイドでは可換律は保証されていないので演算の方向に注意
l >>= 1
r >>= 1
res = self.f(lres, rres)
return res
def main():
N, Q = LI()
C = LI()
lr = LIR1(Q)
tree = SegmentTree(N, f=lambda x, y: x.union(y), default=set())
for i, c in enumerate(C):
tree.update(i, set([c]))
for l, r in lr:
print((len(tree.query(l, r+1))))
if __name__ == '__main__':
main() | #!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.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def S(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
# 0-indexed BIT
class BIT:
def __init__(self, li):
self.n, self.data = len(li) + 1, [0] + li
for i in range(1, self.n):
if i + (i & -i) < self.n: self.data[i + (i & -i)] += self.data[i]
def add(self, i, a):
i += 1
while i < self.n:
self.data[i] += a
i += i & -i
# sum of [0, i)
def acc(self, i):
res = 0
while i > 0:
res += self.data[i]
i -= i & -i
return res
# sum of [l, r)
def get(self, l, r = None):
if r is None: r = l+1
return self.acc(r) - self.acc(l)
def main():
N, Q = LI()
C = LI()
lr = sorted(enumerate(LIR(Q)), key=lambda x: x[1][1])
rightmostIndex = [-1]*(N+1)
tree = BIT([0]*N)
left, right = 0, 0
ans = [None] * Q
for i, (l, r) in lr:
while right < r:
if rightmostIndex[C[right]] < 0:
rightmostIndex[C[right]] = right
else:
tree.add(rightmostIndex[C[right]], -1)
rightmostIndex[C[right]] = right
tree.add(right, 1)
right += 1
ans[i] = tree.get(l-1, r)
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 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)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size : _size + self._len] = data
for i in reversed(list(range(_size))):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def __repr__(self):
return "SegmentTree({0})".format(self.data)
import io
import os
from collections import defaultdict
from bisect import bisect_left, bisect_right
def solve(N, Q, C, LR):
valToIndices = defaultdict(list)
for i, c in enumerate(C):
valToIndices[c].append(i)
THRESHOLD = 500
autoIncrement = defaultdict(lambda: len(autoIncrement))
data = [0] * N
for i, c in enumerate(C):
if len(valToIndices[c]) < THRESHOLD:
data[i] = 1 << autoIncrement[c]
for k in list(valToIndices.keys()):
if len(valToIndices[k]) < THRESHOLD:
del valToIndices[k]
segTree = SegmentTree(data, 0, lambda x, y: x | y)
for l, r in LR:
r += 1
mask = segTree.query(l, r)
lowFreqCount = 0
while mask:
lowFreqCount += mask & 1
mask >>= 1
highFreqCount = 0
for x, indices in list(valToIndices.items()):
if bisect_right(indices, r - 1) - bisect_left(indices, l):
highFreqCount += 1
print((lowFreqCount + highFreqCount))
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N, Q = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
LR = [[int(x) - 1 for x in input().split()] for i in range(Q)] # 0-indexed
solve(N, Q, C, LR)
| 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, 0
currUniq = Counter()
ans = [0] * len(LR)
for i in order:
L, R = LR[i]
while currL < L:
x = C[currL]
currUniq[x] -= 1
if currUniq[x] == 0:
del currUniq[x]
currL += 1
while currL > L:
x = C[currL - 1]
currUniq[x] += 1
if currUniq[x] == 0:
del currUniq[x]
currL -= 1
while currR <= R:
x = C[currR]
currUniq[x] += 1
if currUniq[x] == 0:
del currUniq[x]
currR += 1
while currR > R + 1:
x = C[currR - 1]
currUniq[x] -= 1
if currUniq[x] == 0:
del currUniq[x]
currR -= 1
# print(C[L : R + 1], "is", currUniq)
ans[i] = len(currUniq)
print(("\n".join(map(str, ans))))
if False:
import random
random.seed(0)
N = 5 * 10 ** 5
Q = 5 * 10 ** 5
C = [random.randint(1, N) for i in range(N)]
LR = []
for i in range(Q):
l = random.randint(1, N)
r = random.randint(1, N)
if l > r:
l, r = r, l
LR.append((l, r))
solve(C, LR)
exit()
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N, Q = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
LR = [[int(x) - 1 for x in input().split()] for i in range(Q)] # 0-indexed
solve(C, LR)
| 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=list(map(int,input().split()))
rwork=lst[r-1]
if l==1 :
print((len(rwork)))
continue
lwork=lst[l-2]
sm=len(rwork)
for x in rwork:
if x not in lwork : continue
if rwork[x]==lwork[x]:
sm-=1
print(sm)
main()
| 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:
'''
0-indexed
'''
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
self.depth = N.bit_length()
def _bitsum(self, i):
ret = 0
while i:
ret += self.tree[i]
i ^= i & -i
return ret
# [l,r)の和
def bitsum(self, l, r=None):
if r is None:
return self._bitsum(l)
else:
return self._bitsum(r) - self._bitsum(l)
# i番目にxを追加
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
return
def lower_bound(self, x):
sum_ = 0
pos = 0
v = 1 << self.depth
for i in range(self.depth, -1, -1):
k = pos + v
if k <= self.size and sum_ + self.tree[k] < x:
sum_ += self.tree[k]
pos += v
v >>= 1
return pos + 1, sum_
N,Q=MI()
C=LI()
R=[0]*Q
L=[0]*Q
I=[0]*Q
for i in range(Q):
l,r=MI()
R[i]=r-1
L[i]=l-1
I[i]=i
R,L,I = list(zip(*sorted(zip(R,L,I))))
"""
事前処理 + クエリの高速処理
or
クエリ先読み
とりあえずrの昇順にクエリをソートしておく．
結局，各色ごとに1つ前のやつがどこにあるかが問題=>各色ごとに最新の物だけを保持すれば良い．
最終的にクエリに答えたいので，i番目が使えるかどうかBITで管理
"""
bit=BIT(N+3)
dd=[N+3]*(N+1)#多くとっておく
ans=[0]*Q
pre=-1
for ii in range(Q):
r=R[ii]
l=L[ii]
i=I[ii]
for j in range(pre+1,r+1):
c=C[j]
old=dd[c]#その色の古いやつ
bit.add(old,-1)#もしまだ出てきていないなら，範囲外の使わないところを-1する
#最新を追加
dd[c]=j
bit.add(j,1)
pre=r
ans[i]=bit.bitsum(l,r+1)
for a in ans:
print(a)
main()
| 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:
'''
0-indexed
'''
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
self.depth = N.bit_length()
def _bitsum(self, i):
ret = 0
while i:
ret += self.tree[i]
i ^= i & -i
return ret
# [l,r)の和
def bitsum(self, l, r=None):
if r is None:
return self._bitsum(l)
else:
return self._bitsum(r) - self._bitsum(l)
# i番目にxを追加
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
return
def lower_bound(self, x):
sum_ = 0
pos = 0
v = 1 << self.depth
for i in range(self.depth, -1, -1):
k = pos + v
if k <= self.size and sum_ + self.tree[k] < x:
sum_ += self.tree[k]
pos += v
v >>= 1
return pos + 1, sum_
N,Q=MI()
C=LI()
Query =[]
M=10**6
M2=10**12
for i in range(Q):
l, r = MI()
l-=1
r-=1
Query.append(r*M2 + l*M + i)
Query.sort()
"""
事前処理 + クエリの高速処理
or
クエリ先読み
とりあえずrの昇順にクエリをソートしておく．
結局，各色ごとに1つ前のやつがどこにあるかが問題=>各色ごとに最新の物だけを保持すれば良い．
最終的にクエリに答えたいので，i番目が使えるかどうかBITで管理
"""
bit=BIT(N+3)
dd=[N+3]*(N+1)#多くとっておく
ans=[0]*Q
pre=-1
for q in Query:
r = q // 10 ** 12
l = (q % 10 ** 12) // 10 ** 6
i = q % 10 ** 6
for j in range(pre+1,r+1):
c=C[j]
old=dd[c]#その色の古いやつ
bit.add(old,-1)#もしまだ出てきていないなら，範囲外の使わないところを-1する
#最新を追加
dd[c]=j
bit.add(j,1)
pre=r
ans[i]=bit.bitsum(l,r+1)
for a in ans:
print(a)
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:
'''
0-indexed
'''
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
self.depth = N.bit_length()
def _bitsum(self, i):
ret = 0
while i:
ret += self.tree[i]
i ^= i & -i
return ret
# [l,r)の和
def bitsum(self, l, r=None):
if r is None:
return self._bitsum(l)
else:
return self._bitsum(r) - self._bitsum(l)
# i番目にxを追加
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
return
def lower_bound(self, x):
sum_ = 0
pos = 0
v = 1 << self.depth
for i in range(self.depth, -1, -1):
k = pos + v
if k <= self.size and sum_ + self.tree[k] < x:
sum_ += self.tree[k]
pos += v
v >>= 1
return pos + 1, sum_
N,Q=MI()
C=LI()
Query =[]
M=10**6
M2=10**12
for i in range(Q):
l, r = MI()
l-=1
r-=1
Query.append(r*M2 + l*M + i)
Query.sort()
"""
事前処理 + クエリの高速処理
or
クエリ先読み
とりあえずrの昇順にクエリをソートしておく．
結局，各色ごとに1つ前のやつがどこにあるかが問題=>各色ごとに最新の物だけを保持すれば良い．
最終的にクエリに答えたいので，i番目が使えるかどうかBITで管理
"""
bit=BIT(N+3)
dd=[N+3]*(N+1)#多くとっておく
ans=[0]*Q
pre=-1
for q in Query:
r = q // 10 ** 12
l = (q % 10 ** 12) // 10 ** 6
i = q % 10 ** 6
for j in range(pre+1,r+1):
c=C[j]
old=dd[c]#その色の古いやつ
bit.add(old,-1)#もしまだ出てきていないなら，範囲外の使わないところを-1する
#最新を追加
dd[c]=j
bit.add(j,1)
pre=r
ans[i]=bit.bitsum(l,r+1)
for a in ans:
print(a)
main()
| 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):
self.size = N
self.tree = [0] * (N + 1)
self.depth = N.bit_length()
def _bitsum(self, i):
ret = 0
while i:
ret += self.tree[i]
i ^= i & -i
return ret
# [l,r)の和
def bitsum(self, l, r=None):
if r is None:
return self._bitsum(l)
else:
return self._bitsum(r) - self._bitsum(l)
# i番目にxを追加
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i] += x
i += i & -i
return
def lower_bound(self, x):
sum_ = 0
pos = 0
v = 1 << self.depth
for i in range(self.depth, -1, -1):
k = pos + v
if k <= self.size and sum_ + self.tree[k] < x:
sum_ += self.tree[k]
pos += v
v >>= 1
return pos + 1, sum_
N,Q=MI()
C=LI()
Query =[]
M=10**6
M2=10**12
for i in range(Q):
l, r = MI()
l-=1
r-=1
Query.append(r*M2 + l*M + i)
Query.sort()
"""
事前処理 + クエリの高速処理
or
クエリ先読み
とりあえずrの昇順にクエリをソートしておく．
結局，各色ごとに1つ前のやつがどこにあるかが問題=>各色ごとに最新の物だけを保持すれば良い．
最終的にクエリに答えたいので，i番目が使えるかどうかBITで管理
"""
bit=BIT(N+3)
dd=[N+3]*(N+1)#多くとっておく
ans=[0]*Q
pre=-1
for q in Query:
r = q // 10 ** 12
l = (q % 10 ** 12) // 10 ** 6
i = q % 10 ** 6
for j in range(pre+1,r+1):
c=C[j]
old=dd[c]#その色の古いやつ
bit.add(old,-1)#もしまだ出てきていないなら，範囲外の使わないところを-1する
#最新を追加
dd[c]=j
bit.add(j,1)
pre=r
ans[i]=bit.bitsum(l,r+1)
for a in ans:
print(a)
main()
| 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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
self.depth = n.bit_length()
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [[0, i]]
Q[r - 1] += [[1, i]]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
now = 0
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
now += 1
# print(q_now, "b")
print(*ans, sep="\n")
| 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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
self.depth = n.bit_length()
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [(0, i)]
Q[r - 1] += [(1, i)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
now = 0
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
now += 1
# print(q_now, "b")
print(*ans, sep="\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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
self.depth = n.bit_length()
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [(False, i)]
Q[r - 1] += [(True, i)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
# print(q_now, "b")
print(*ans, sep="\n")
| 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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
self.depth = n.bit_length()
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [(False, i)]
Q[r - 1] += [(True, i)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
# print(q_now, "b")
print(*ans, sep="\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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
self.depth = n.bit_length()
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [(False, i)]
Q[r - 1] += [(True, i)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
# print(q_now, "b")
print(*ans, sep="\n")
| 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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [(False, i)]
Q[r - 1] += [(True, i)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
# print(q_now, "b")
print(*ans, sep="\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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[l - 1] += [(False, i)]
Q[r - 1] += [(True, i)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for flg, qi in Q[i]:
if flg:
ans[qi] = bit.sum(i) - bit.sum(DD[qi] - 1)
else:
DD[qi] = i
# print(q_now, "b")
print(*ans, sep="\n")
| 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, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, n):
self.num = n
self.dat = [0] * (self.num + 1)
def add(self, i, x):
i += 1
while i <= self.num:
self.dat[i] += x
i += i & -i
def sum(self, i):
i += 1
s = 0
while i > 0:
s += self.dat[i]
i -= i & -i
return s
n, q = LI()
ans = [0] * q
C = LI()
Q = [[] for _ in range(n)]
for i in range(q):
l, r = LI()
Q[r - 1] += [(i, l - 1)]
last = [-1] * (n + 1)
DD = {}
bit = BIT(n + 1)
for i, c in enumerate(C):
col = C[i]
bit.add(i, 1)
if last[col] != -1:
bit.add(last[col], -1)
last[col] = i
for qi, li in Q[i]:
ans[qi] = bit.sum(i) - bit.sum(li - 1)
print(*ans, sep="\n")
| 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):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
class BIT:
"""
a[1]~a[n]の数列を想定
"""
def __init__(self,n):
self.size = n
self.tree = [0]*(n+1)
def add(self,index,x):
"""
a[index]にxを加算
"""
while index <= self.size:
self.tree[index] += x
index += index & (-index)
def sum(self,index):
"""
a[1]~a[index]の和
"""
s = 0
while index:
s += self.tree[index]
index -= index & (-index)
return s
def search(self,value):
"""
sum(index) >= value を満たす最小のindex
sum(n) < value のとき n+1 を返す
"""
i = 0
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i+step <= self.size and s + self.tree[i+step] < value:
i += step
s += self.tree[i]
step >>= 1
return i + 1
N,Q = LI()
c = LI()
l,r = LIR(Q,2)
x = []
for i in range(Q):
x.append((i,l[i],r[i]))
x.sort(key=lambda x: (x[2],x[1]))
bit = BIT(N)
ans = [0]*Q
last = [-1]*(N+1)
right = -1 # 確認し終わった右端
for i in range(Q):
for j in range(right+1,x[i][2]):
bit.add(j+1,1)
if last[c[j]] != -1:
bit.add(last[c[j]]+1,-1)
last[c[j]] = j
right = x[i][2]-1
ans[x[i][0]] = bit.sum(x[i][2]) - bit.sum(x[i][1]-1)
for a in ans:
print(a) | 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):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return list(map(list, list(zip(*read_all))))
#################
class BIT:
"""
a[1]~a[n]の数列を想定
"""
def __init__(self,n):
self.size = n
self.tree = [0]*(n+1)
def add(self,index,x):
"""
a[index]にxを加算
"""
while index <= self.size:
self.tree[index] += x
index += index & (-index)
def sum(self,index):
"""
a[1]~a[index]の和
"""
s = 0
while index:
s += self.tree[index]
index -= index & (-index)
return s
def search(self,value):
"""
sum(index) >= value を満たす最小のindex
sum(n) < value のとき n+1 を返す
"""
i = 0
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i+step <= self.size and s + self.tree[i+step] < value:
i += step
s += self.tree[i]
step >>= 1
return i + 1
N,Q = LI()
c = LI()
l,r = LIR(Q,2)
x = []
for i in range(Q):
x.append((i,l[i],r[i]))
x.sort(key=lambda x: x[2])
bit = BIT(N)
ans = [0]*Q
last = [-1]*(N+1)
right = -1 # 確認し終わった右端
for i in range(Q):
for j in range(right+1,x[i][2]):
bit.add(j+1,1)
if last[c[j]] != -1:
bit.add(last[c[j]]+1,-1)
last[c[j]] = j
right = x[i][2]-1
ans[x[i][0]] = bit.sum(x[i][2]) - bit.sum(x[i][1]-1)
for a in ans:
print(a) | 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 += self.data[i]
i = (i & (i + 1)) - 1
return s
def sum_range(self, start, end):
return self.sum_to(end) - self.sum_to(start)
def add(self, idx, x):
while idx < self.num_elems:
self.data[idx] += x
idx |= idx + 1
def answer_queries(n, q, cs, queries):
ft = FenwickTree(n + 1)
last_visit = [-1] * MAX_VAL
sorted_queries = sorted(queries, key=lambda x: x[1])
ans = [0] * q
qc = 0
for i in range(n):
if last_visit[cs[i]] != -1:
ft.add(last_visit[cs[i]], -1)
last_visit[cs[i]] = i
ft.add(i, 1)
while qc < q and sorted_queries[qc][1] == i:
sqqc = sorted_queries[qc]
ans[sqqc[2]] = ft.sum_range(sqqc[0], sqqc[1] + 1)
qc += 1
for i in range(q):
yield ans[i]
def main():
n, q = (int(z) for z in input().split())
cs = [int(c) for c in input().split()]
queries = []
for i in range(q):
le, ri = (int(z) - 1 for z in input().split())
queries.append((le, ri, i))
for a in answer_queries(n, q, cs, queries):
print(a)
if __name__ == '__main__':
main() | #!/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.data[i]
i = (i & (i + 1)) - 1
return s
def sum_range(self, start, end):
return self.sum_to(end) - self.sum_to(start)
def add(self, idx, x):
while idx < self.num_elems:
self.data[idx] += x
idx |= idx + 1
def answer_queries(n, q, cs, queries):
ft = FenwickTree(n + 1)
last_visit = [-1] * MAX_VAL
sorted_queries = sorted(queries, key=lambda x: x[1])
ans = [0] * q
qc = 0
for i in range(n):
if last_visit[cs[i]] != -1:
ft.add(last_visit[cs[i]], -1)
last_visit[cs[i]] = i
ft.add(i, 1)
while qc < q and sorted_queries[qc][1] == i:
sqqc = sorted_queries[qc]
ans[sqqc[2]] = ft.sum_range(sqqc[0], sqqc[1] + 1)
qc += 1
for i in range(q):
yield ans[i]
def main():
n, q = (int(z) for z in input().split())
cs = [int(c) for c in input().split()]
queries = []
for i in range(q):
le, ri = (int(z) - 1 for z in input().split())
queries.append((le, ri, i))
for a in answer_queries(n, q, cs, queries):
print(a)
if __name__ == '__main__':
main() | 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 range((i << 1))]
def update(self, i, x) :
i += self.n - 1
self.tree[i].add(x)
while i > 0 :
i = (i - 1) // 2
self.tree[i] = self.tree[i * 2 + 1] | self.tree[i * 2 + 2]
# [l, r)
def query(self, l, r) :
l = l + self.n
r = r + self.n
s = set()
while l < r :
if r & 1 :
r -= 1
s |= self.tree[r - 1]
if l & 1 :
s |= self.tree[l - 1]
l += 1
l >>= 1
r >>= 1
return len(s)
ST = SegTree(N + 5)
for i in range(N) :
ST.update(i, c[i])
for l, r in lr :
print((ST.query(l - 1, r))) | 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) :
s = 0
while i > 0 :
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x) :
while i <= self.n :
self.tree[i] += x
i += i & -i
BIT = BinaryIndexedTree(N + 5)
sch = [[i, l, r] for i, (l, r) in enumerate(lr)]
sch.sort(key=lambda x: x[2])
ret = [0] * Q
last = [-1] * (N + 1)
cur = 0
for i, l, r in sch :
while cur <= r :
BIT.add(cur + 1, 1)
pos = last[c[cur]]
if pos != -1 :
BIT.add(pos + 1, -1)
last[c[cur]] = cur
cur += 1
ret[i] = BIT.sum(r + 1) - BIT.sum(l)
for r in ret :
print(r) | 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=[0 for _ in range(500001)]
col=0
cnt[c[0]]=1
for l,r,j in que:
while rr<r:
if cnt[c[rr+1]]==0:
col+=1
cnt[c[rr+1]]+=1
rr+=1
while rr>r:
if cnt[c[rr]]==1:
col-=1
cnt[c[rr]]-=1
rr-=1
while ll>l:
if cnt[c[ll-1]]==0:
col+=1
cnt[c[ll-1]]+=1
ll-=1
while ll<l:
if cnt[c[ll]]==1:
col-=1
cnt[c[ll]]-=1
ll+=1
ans[j]=col+1
print(('\n'.join(map(str,ans[:q]))))
| 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 query(t):
res=0
while t:
res+=bit[t]
t-=t&(-t)
return res
used=1
ans=[0]*q
for l,r,i in qu:
while used<=r:
add(used,1)
if last[c[used-1]]>=0:
add(last[c[used-1]],-1)
last[c[used-1]]=used
used+=1
ansi=query(r)-query(l-1)
ans[i]=ansi
for ansi in ans:
print(ansi)
| 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 to idx-th element
# idx: 1-indexed
self.data[idx] += x
while idx <= self.n:
self.bit[idx] += x
idx += (idx & (-idx))
def sum(self, idx):
# get sum of [1, idx]
# idx: 1-indexed
s = 0
while idx:
s += self.bit[idx]
idx -= (idx & (-idx))
return s
n, q = map(int, input().split())
c = list(map(int, input().split()))
queries = []
for i in range(q):
l, r = map(int, input().split())
l -= 1
r -= 1
queries.append((i, l, r))
queries.sort(key=itemgetter(2))
ans = [0] * q
# last_visit[i] = 色iの最後のindex
last_visit = [-1] * (n + 1)
query_counter = 0
bit = BIT1(n)
for i in range(n):
if last_visit[c[i]] != -1:
bit.add(last_visit[c[i]] + 1, -1)
last_visit[c[i]] = i
bit.add(i + 1, +1)
while query_counter < q and queries[query_counter][2] == i:
idx, l, r = queries[query_counter]
ans[idx] = bit.sum(r + 1) - bit.sum(l)
query_counter += 1
print(*ans, sep='\n')
| 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 to idx-th element
# idx: 1-indexed
self.data[idx] += x
while idx <= self.n:
self.bit[idx] += x
idx += (idx & (-idx))
def sum(self, idx):
# get sum of [1, idx]
# idx: 1-indexed
s = 0
while idx:
s += self.bit[idx]
idx -= (idx & (-idx))
return s
def main():
n, q = map(int, input().split())
c = list(map(int, input().split()))
queries = []
for i in range(q):
l, r = map(int, input().split())
l -= 1
r -= 1
queries.append((i, l, r))
queries.sort(key=itemgetter(2))
ans = [0] * q
# last_visit[i] = 色iの最後のindex
last_visit = [-1] * (n + 1)
query_counter = 0
bit = BIT1(n)
for i in range(n):
if last_visit[c[i]] != -1:
bit.add(last_visit[c[i]] + 1, -1)
last_visit[c[i]] = i
bit.add(i + 1, +1)
while query_counter < q and queries[query_counter][2] == i:
idx, l, r = queries[query_counter]
ans[idx] = bit.sum(r + 1) - bit.sum(l)
query_counter += 1
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| 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 enumerate(a):
self.b[i + self.n - 1] = j
for i in reversed(list(range(self.n - 1))):
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_item(self, i):
return self.b[i + self.n - 1]
def update(self, index, x):
i = index + self.n - 1
self.b[i] = x
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def update_func(self, index, x):
i = index + self.n - 1
self.b[i] = self.func(self.b[i], x)
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_segment(self, l, r):
l += self.n
r += self.n
s = self.one
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.b[r - 1])
if l & 1:
s = self.func(s, self.b[l - 1])
l += 1
l >>= 1
r >>= 1
return s
c = [int(i) for i in input().split()]
seg = SegmentTree([{i} for i in c], lambda x, y: x | y, set())
for _ in range(q):
l, r = [int(i) for i in input().split()]
print((len(seg.get_segment(l-1, r)))) | 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:
self.a[i] = self.func(self.a[i], x)
i += i & (-i)
def get(self, i):
i += 1
s = self.one
while i != 0:
s = self.func(s, self.a[i])
i -= i & (-i)
return s
n, q = list(map(int, input().split()))
c = [int(i)-1 for i in input().split()]
que = [[i, [int(i)-1 for i in input().split()], 0] for i in range(q)]
que.sort(key=lambda x: x[1][1])
last = [-1] * n
bit = BIT([0]*(n+100))
j = 0
for i in range(n):
if last[c[i]] != -1:
bit.update(last[c[i]], -1)
bit.update(i, 1)
last[c[i]] = i
while j < q and que[j][1][1] == i:
que[j][2] = bit.get(i) - bit.get(que[j][1][0]-1)
j += 1
que.sort()
for i in que:
print((i[-1]))
| 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
idx+=idx&(-idx)
return
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)
#A1 ... AnのBIT(1-indexed)
BIT=[0]*(N+1)
ANS=[0]*Q
now=1
for r,l,i in LRI:
while now<=r:
c=C[now-1]
#初めてその種類が登場
if lastAppend[c]==-1:
BIT_update(BIT,now,1,N)
#その種類の登場が2回目
else:
BIT_update(BIT,now,1,N)
BIT_update(BIT,lastAppend[c],-1,N)
lastAppend[c]=now
now+=1
ANS[i]=BIT_query(BIT,r)-BIT_query(BIT,l-1)
for ans in ANS:
print(ans) | #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
idx+=idx&(-idx)
return
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)
ANS = [0]*Q
now = 1
for r, l, i in LRI:
while now <= r:
c = C[now-1]
if lastAppend[c] == -1:
BIT_update(BIT, now, 1,N)
else:
BIT_update(BIT, now, 1,N)
BIT_update(BIT, lastAppend[c],-1,N)
lastAppend[c] = now
now += 1
ANS[i] = BIT_query(BIT,r) - BIT_query(BIT,l-1)
for ans in ANS:
print(ans)
if __name__ == '__main__':
main() | 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, input().split()))
LRI=[]
for i in range(Q):
l,r=list(map( int, input().split()))
LRI.append((r,l,i))
LRI=sorted(LRI)
lastAppend=[-1]*(N+1)
BIT=[0]*(N+1)
ANS=[0]*Q
now=1
for r,l,i in LRI:
while now <= r:
c=C[now-1]
if lastAppend[c]== -1:
BIT_update(BIT,now,1,N)
else:
BIT_update(BIT,now,1,N)
BIT_update(BIT,lastAppend[c],-1,N)
lastAppend[c]=now
now+=1
ANS[i] = BIT_query(BIT,r) - BIT_query(BIT,l-1)
for ans in ANS:
print(ans)
if __name__ == '__main__':
main() | 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(logN)
def BIT_query(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(idx,x):
while idx <= N:
BIT[idx] += x
idx += idx&(-idx)
return
ANS = [0]*Q
now = 1
for r, l, i in LRI:
while now <= r:
c = C[now-1]
if lastAppend[c] == -1:
BIT_update(now, 1)
else:
BIT_update( now, 1)
BIT_update(lastAppend[c],-1)
lastAppend[c] = now
now += 1
ANS[i] = BIT_query(r) - BIT_query(l-1)
print(( "\n".join( map( str, ANS))))
if __name__ == '__main__':
main() | 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, 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)
ANS=[0]*Q
now=1
for r,l,i in LRI:
while now <= r:
c=C[now-1]
if lastAppend[c]== -1:
BIT_update(BIT,now,1,N)
else:
BIT_update(BIT,now,1,N)
BIT_update(BIT,lastAppend[c],-1,N)
lastAppend[c]=now
now+=1
ANS[i] = BIT_query(BIT,r) - BIT_query(BIT,l-1)
for ans in ANS:
print(ans)
if __name__ == '__main__':
main() | 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):
while idx<=n:
BIT[idx]+=x
idx+=idx&(-idx)
return
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)
#A1 ... AnのBIT(1-indexed)
BIT=[0]*(N+1)
ANS=[0]*Q
now=1
for r,l,i in LRI:
while now<=r:
c=C[now-1]
#初めてその種類が登場
if lastAppend[c]==-1:
BIT_update(BIT,now,1,N)
#その種類の登場が2回目
else:
BIT_update(BIT,now,1,N)
BIT_update(BIT,lastAppend[c],-1,N)
lastAppend[c]=now
now+=1
ANS[i]=BIT_query(BIT,r)-BIT_query(BIT,l-1)
for ans in ANS:
print(ans)
| 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 i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10
class BIT:
""" Binary Indexed Tree """
def __init__(self, n):
# 0-indexed
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def update(self, i, x):
""" 値の更新：添字i, 値x """
self.add(i, x - self.get(i))
N, Q = MAP()
A = [a-1 for a in LIST()]
prev = [-1] * N
events = []
bit = BIT(N)
for t, a in enumerate(A):
s = prev[a]
if s != -1:
events.append((t, 0, s))
prev[a] = t
for i in range(Q):
l, r = MAP()
l -= 1; r -= 1
events.append((r, 1, l, i))
events.sort(key=itemgetter(0, 1))
ans = [0] * Q
for event in events:
if event[1] == 0:
t, _, s = event
bit.add(s, 1)
else:
r, _, l, i = event
total = r - l + 1
ans[i] = total - bit.get(l, N)
for a in ans:
print(a)
| 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 i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10
class BIT:
""" Binary Indexed Tree """
def __init__(self, n):
# 0-indexed
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def update(self, i, x):
""" 値の更新：添字i, 値x """
self.add(i, x - self.get(i))
N, Q = MAP()
A = [a-1 for a in LIST()]
prev = [-1] * N
events = []
bit = BIT(N)
for t, a in enumerate(A):
s = prev[a]
if s != -1:
events.append((t, 0, s))
prev[a] = t
for i in range(Q):
l, r = MAP()
l -= 1; r -= 1
events.append((r, 1, l, i))
events.sort(key=itemgetter(0))
ans = [0] * Q
for event in events:
# 色の区間が来たら、点を追加
if event[1] == 0:
t, _, s = event
bit.add(s, 1)
# クエリが来たら、点の数を数える
else:
r, _, l, i = event
total = r - l + 1
# 区間全体 - この時の領域内の点の数
ans[i] = total - bit.get(l, N)
for a in ans:
print(a)
| 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 i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10
class BIT:
""" Binary Indexed Tree """
def __init__(self, n):
# 0-indexed
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def update(self, i, x):
""" 値の更新：添字i, 値x """
self.add(i, x - self.get(i))
N, Q = MAP()
A = [a-1 for a in LIST()]
prev = [-1] * N
events = []
bit = BIT(N)
for t, a in enumerate(A):
s = prev[a]
if s != -1:
events.append((t, 0, s))
prev[a] = t
for i in range(Q):
l, r = MAP()
l -= 1; r -= 1
events.append((r, 1, l, i))
events.sort(key=itemgetter(0))
ans = [0] * Q
for event in events:
# 色の区間が来たら、点を追加
if event[1] == 0:
t, _, s = event
bit.add(s, 1)
# クエリが来たら、点の数を数える
else:
r, _, l, i = event
total = r - l + 1
# 区間全体 - この時の領域内の点の数
ans[i] = total - bit.get(l, N)
for a in ans:
print(a)
| 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(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10
class BIT:
""" Binary Indexed Tree """
def __init__(self, n):
# 0-indexed
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def update(self, i, x):
""" 値の更新：添字i, 値x """
self.add(i, x - self.get(i))
N, Q = MAP()
A = [a-1 for a in LIST()]
prev = [-1] * N
events = []
bit = BIT(N)
for t, a in enumerate(A):
s = prev[a]
if s != -1:
events.append((t, 0, s))
prev[a] = t
for i in range(Q):
l, r = MAP()
l -= 1; r -= 1
events.append((r, 1, l, i))
events.sort(key=itemgetter(0))
ans = [0] * Q
for event in events:
# 色の区間が来たら、点を追加
if event[1] == 0:
t, _, s = event
bit.add(s, 1)
# クエリが来たら、点の数を数える
else:
r, _, l, i = event
total = r - l + 1
# 区間全体 - この時の領域内の点の数
ans[i] = total - bit.get(l, N)
for a in ans:
print(a)
| 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(int, input().strip().split() ))
Queries[i] = [l, r]
color = colors[0]-1
Num_colors_list[0][color] =1
for i in range(1, N):
color = colors[i]-1
for j in range(N):
Num_colors_list[i][j] =Num_colors_list[i-1][j]
Num_colors_list[i][color] += 1
#print(Num_colors_list)
for q in range(Q):
N_color_lr = 0
query = Queries[q]
if(query[0] == 1):
for i in range(N):
if(Num_colors_list[ query[1]-1 ][i]>0):
N_color_lr += 1
else:
for i in range(N):
if(Num_colors_list[ query[1]-1 ][i]- Num_colors_list[ query[0]-2 ][i]>0):
N_color_lr += 1
print(N_color_lr)
| 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[i] = [l, r]
colors_pos = [ [] for _ in range(N) ]
for i in range(N):
color = colors[i]-1
colors_pos[color].append(i)
for q in range(Q):
N_color_lr = 0
query = Queries[q]
left = query[0] -1
right = query[1] - 1
N_types = 0
if(left==0):
#rightで考える
for i in range(N):
if( bisect.bisect_right(colors_pos[i], right) >0):
N_types += 1
else:
for i in range(N):
if( bisect.bisect_right(colors_pos[i], right) - bisect.bisect_left(colors_pos[i], left) >0):
N_types += 1
print(N_types)
| p02599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.