input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
input = lambda: sys.stdin.readline().rstrip('\r\n')
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
div = max(int(Q**.5), 1)
B = N // div
Qs = []
for i in range(Q):
l, r = [int(s)-1 for s in input().split()]
Qs.append((l, r+1, i))
Qs.sort(key=lambda v: (v[0]//B, v[1] ^ -(v[0]//B & 1)))
cnt = [0] * (N+1)
diff = 0
ans = [-1] * Q
left, right = 0, 0
def add(i):
global cnt, diff
x = C[i]
cnt[x] += 1
if cnt[x] == 1:
diff += 1
def remove(i):
global cnt, diff
x = C[i]
cnt[x] -= 1
if cnt[x] == 0:
diff -= 1
for l, r, i in Qs:
while right < r:
add(right)
right += 1
while r < right:
right -= 1
remove(right)
while left < l:
remove(left)
left += 1
while l < left:
left -= 1
add(left)
ans[i] = diff
print(('\n'.join(map(str, ans))))
| import sys
input = lambda: sys.stdin.readline().rstrip('\r\n')
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
by_R = [[] for _ in range(N+1)]
for i in range(Q):
l, r = [int(s)-1 for s in input().split()]
by_R[r+1].append((l, i))
s = [0] * N
def update(pos, dif):
while pos < N:
s[pos] += dif
pos |= pos + 1
def query(pos):
res = 0
while pos > 0:
res += s[pos-1]
pos &= pos - 1
return res
diff = 0
ans = [-1] * Q
last = [-1] * (N+1)
for i, v in enumerate(C):
if last[v] != -1:
update(last[v], -1)
else:
diff += 1
update(i, 1)
last[v] = i
for l, j in by_R[i+1]:
ans[j] = diff - query(l)
print(('\n'.join(map(str, ans))))
| p02599 |
import sys
rd = sys.stdin.readline
n,q = list(map(int,rd().split()))
c = list(map(int,rd().split()))
# セグ木
#使う操作
#####segfunc#####
def segfunc1(x, y):
return x | y
#################
#####ide_ele#####
ide_ele1 = set()
#################
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
c = [{i} for i in c]
seg = SegTree(c, segfunc1, ide_ele1)
for i in range(q):
l,r = list(map(int,rd().split()))
print((len(seg.query(l-1, r)))) | import sys
rd = sys.stdin.readline
class BIT:
def __init__(self,len_A):
self.N = len_A + 10
self.bit = [0]*(len_A+10)
# sum(A0 ~ Ai)
# O(log N)
def query(self,i):
res = 0
idx = i+1
while idx:
res += self.bit[idx]
idx -= idx&(-idx)
return res
# Ai += x
# O(log N)
def add(self,i,x):
idx = i+1
while idx < self.N:
self.bit[idx] += x
idx += idx&(-idx)
# min_i satisfying {sum(A0 ~ Ai) >= w} (Ai >= 0)
# O(log N)
def lower_left(self,w):
if (w < 0):
return -1
x = 0
k = 1<<(self.N.bit_length()-1)
while k > 0:
if x+k < self.N and self.bit[x+k] < w:
w -= self.bit[x+k]
x += k
k //= 2
return x
n,q = map(int,rd().split())
c = list(map(int,rd().split()))
lr = []
for i in range(q):
l,r = map(int,rd().split())
lr.append([l,r,i])
lr.sort(key = lambda x:x[1])
last = [-1]*(n+1)
bit = BIT(n+1)
ans = [0]*q
current = 1
for i in range(q):
# rightに達するまで
while current <= lr[i][1]:
# 今の色が過去にあった場合、bitの値を0に戻す
if last[c[current-1]] != -1:
bit.add(last[c[current-1]], -1)
last[c[current-1]] = current
bit.add(current, 1)
current += 1
ans[lr[i][2]] = bit.query(lr[i][1]) - bit.query(lr[i][0] - 1)
print(*ans, sep = "\n")
| p02599 |
x=lambda:list(map(int,input().split()))
def build(s,e,index):
if s==e:
seg[index] = {arr[s]}
return
mid = (s+e)//2
build(s,mid,2*index)
build(mid+1,e,2*index+1)
seg[index] = set(list(seg[2*index]) + list(seg[2*index+1]))
return
def query(s,e,qs,qe,index):
if qe<s or qs>e:
return set()
if s>=qs and e<=qe:
return seg[index]
mid = (s+e)//2
left=query(s,mid,qs,qe,2*index)
right=query(mid+1,e,qs,qe,2*index+1)
return set(list(left)+list(right))
n,q = x()
arr = x()
seg=[-1]*(4*n+1)
build(0,n-1,1)
for _ in range(q):
l,r = x()
l-=1
r-=1
print((len(list(query(0,n-1,l,r,1)))))
| x=lambda:list(map(int,input().split()))
n,q = x()
arr = x()
for _ in range(q):
l,r = x()
l-=1
print((len(list(set(arr[l:r])))))
| p02599 |
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range;R=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def Ra():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:
a,b=inp;c=1
else:
a,b,c=inp
if index==1:a-=1;b-=1
aa=(a,c);bb=(b,c);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in R(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
rt=[0]
for i in ls:rt+=[rt[-1]+i]
return rt
def bit_combination(n,base=2):
rt=[]
for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**9)
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
########################################################################################################################################################################
# Verified by
# https://atcoder.jp/contests/arc033/submissions/me
# https://atcoder.jp/contests/abc174/tasks/abc174_f
#
# Binary Indexed Tree
# Bit.add(i,x) : add x at i-th value
# Bit.sum(i) : get sum up to i-th value
# Bit.l_bound(w) : get lower bound of index where w can be inserted
class Bit:
def __init__(self,n,init=None):
self.size=n
self.m=len(bin(self.size))-2
self.arr=[0]*(2**self.m+1)
if init!=None:
for i in range(len(init)):
self.add(i,init[i])
def __str__(self):
a=[self.sum(i+1)-self.sum(i) for i in range(self.size)]
return str(a)
def add(self,i,x):
if not 0<i<=self.size:return NotImplemented
while i<=self.size:
self.arr[i]+=x
i+=i&(-i)
return
def sum(self,i):
if not 0<=i<=self.size:return NotImplemented
rt=0
while i>0:
rt+=self.arr[i]
i-=i&(-i)
return rt
def __getitem__(self,key):
return self.sum(key+1)-self.sum(key)
def __setitem__(self,key,value):
self.add(key,value-self.sum(key+1)+self.sum(key))
def l_bound(self,w):
if w<=0:
return 0
x=0
k=2**self.m
while k>0:
if x+k<=self.size and self.arr[x+k]<w:
w-=self.arr[x+k]
x+=k
k>>=1
return x+1
def u_bound(self,w):
if w<=0:
return 0
x=0
k=2**self.m
while k>0:
if x+k<=self.size and self.arr[x+k]<=w:
w-=self.arr[x+k]
x+=k
k>>=1
return x+1
class Bit0(Bit):
def add(self,j,x):
super().add(j+1,x)
def l_bound(self,w):
return max(super().l_bound(w)-1,0)
def u_bound(self,w):
return max(super().u_bound(w)-1,0)
class Multiset(Bit0):
def __init__(self,max_v):
super().__init__(max_v)
def insert(self,x):
super().add(x,1)
def find(self,x):
return super().l_bound(super().sum(x))
def __str__(self):
return str(self.arr)
def compress(L):
dc={v:i for i,v in enumerate(sorted(set(L)))}
return [dc[i] for i in L]
show_flg=False
show_flg=True
ans=0
n,Q=LI()
c=LI_()
q=[(i,LI())for i in range(Q)]
q.sort(key=lambda x:x[1][1])
bt=Bit0(-~n)
lst=[-1]*-~n
ans=[0]*Q
R=0
for j,(l,r) in q:
while R<r:
col=c[R]
if lst[col]!=-1:
bt[lst[col]]=0
#bt.add(lst[col],-1)
lst[col]=R
#bt.add(lst[col],1)
bt[lst[col]]=1
R+=1
ans[j]=bt.sum(r+1)-bt.sum(l-1)
for i in ans:
print(i)
| import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range;R=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def Ra():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:
a,b=inp;c=1
else:
a,b,c=inp
if index==1:a-=1;b-=1
aa=(a,c);bb=(b,c);g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in R(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
rt=[0]
for i in ls:rt+=[rt[-1]+i]
return rt
def bit_combination(n,base=2):
rt=[]
for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**9)
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
########################################################################################################################################################################
# Verified by
# https://atcoder.jp/contests/arc033/submissions/me
# https://atcoder.jp/contests/abc174/tasks/abc174_f
#
# Binary Indexed Tree
# Bit.add(i,x) : add x at i-th value
# Bit.sum(i) : get sum up to i-th value
# Bit.l_bound(w) : get lower bound of index where w can be inserted
class Bit:
def __init__(self,n,init=None):
self.size=n
self.m=len(bin(self.size))-2
self.arr=[0]*(2**self.m+1)
self.el=[0]*(2**self.m+1)
if init!=None:
for i in range(len(init)):
self.add(i,init[i])
self.el[i]=init[i]
def __str__(self):
a=[self.sum(i+1)-self.sum(i) for i in range(self.size)]
return str(a)
def add(self,i,x):
if not 0<i<=self.size:return NotImplemented
self.el[i]+=x
while i<=self.size:
self.arr[i]+=x
i+=i&(-i)
return
def sum(self,i):
if not 0<=i<=self.size:return NotImplemented
rt=0
while i>0:
rt+=self.arr[i]
i-=i&(-i)
return rt
def __getitem__(self,key):
return self.el[key]
return self.sum(key+1)-self.sum(key)
def __setitem__(self,key,value):
self.add(key,value-self.sum(key+1)+self.sum(key))
def l_bound(self,w):
if w<=0:
return 0
x=0
k=2**self.m
while k>0:
if x+k<=self.size and self.arr[x+k]<w:
w-=self.arr[x+k]
x+=k
k>>=1
return x+1
def u_bound(self,w):
if w<=0:
return 0
x=0
k=2**self.m
while k>0:
if x+k<=self.size and self.arr[x+k]<=w:
w-=self.arr[x+k]
x+=k
k>>=1
return x+1
class Bit0(Bit):
def add(self,j,x):
super().add(j+1,x)
def l_bound(self,w):
return max(super().l_bound(w)-1,0)
def u_bound(self,w):
return max(super().u_bound(w)-1,0)
class Multiset(Bit0):
def __init__(self,max_v):
super().__init__(max_v)
def insert(self,x):
super().add(x,1)
def find(self,x):
return super().l_bound(super().sum(x))
def __str__(self):
return str(self.arr)
def compress(L):
dc={v:i for i,v in enumerate(sorted(set(L)))}
return [dc[i] for i in L]
show_flg=False
show_flg=True
ans=0
n,Q=LI()
c=LI_()
q=[(i,LI())for i in range(Q)]
q.sort(key=lambda x:x[1][1])
bt=Bit0(-~n)
lst=[-1]*-~n
ans=[0]*Q
R=0
for j,(l,r) in q:
while R<r:
col=c[R]
if lst[col]!=-1:
bt[lst[col]]=0
#bt.add(lst[col],-1)
lst[col]=R
#bt.add(lst[col],1)
bt[lst[col]]=1
R+=1
ans[j]=bt.sum(r+1)-bt.sum(l-1)
for i in ans:
print(i)
| p02599 |
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
N, Q = list(map(int, input().split()))
Cs = [0] + list(map(int, input().split()))
Qs = []
for i in range(Q):
l,r = list(map(int, input().split()))
Qs.append((i,l,r))
Qs.sort(key=lambda x:x[2])
ans = [-1]*Q
dic = {}
b = 1
bt = BIT(N)
for i,l,r in Qs:
st = set()
for j in range(b,r+1):
if not Cs[j] in st and Cs[j] in dic:
bt.add(dic[Cs[j]],-1)
st.add(Cs[j])
dic[Cs[j]] = j
for s in st:
bt.add(dic[s], 1)
ans[i] = bt.get(l-1,r)
b = r + 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()))
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 BIT:
def __init__(self, n):
self.n = n
self.data = [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
while i <= self.n:
self.data[i] += x
i += i & -i
N, Q = list(map(int, input().split()))
Cs = [0] + list(map(int, input().split()))
Qs = []
for i in range(Q):
l,r = list(map(int, input().split()))
Qs.append((i,l,r))
Qs.sort(key=lambda x:x[2])
ans = [-1]*Q
dic = {}
b = 1
bt = BIT(N)
for i,l,r in Qs:
if b < r + 1:
st = set()
for j in range(b,r+1):
if not Cs[j] in st and Cs[j] in dic:
bt.add(dic[Cs[j]],-1)
st.add(Cs[j])
dic[Cs[j]] = j
for s in st:
bt.add(dic[s], 1)
b = r + 1
ans[i] = bt.sum(r) - bt.sum(l-1)
for a in ans:
print(a) | class BIT:
def __init__(self, n):
self.n = n
self.data = [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):
while i <= self.n:
self.data[i] += x
i += i & -i
N, Q = list(map(int, input().split()))
Cs = [0] + list(map(int, input().split()))
Qs = [None]*Q
for i in range(Q):
l,r = list(map(int, input().split()))
Qs[i] = [i,l,r]
Qs.sort(key=lambda x:x[2])
ans = [-1]*Q
dic = {}
b = 1
bt = BIT(N)
for i,l,r in Qs:
st = set()
for j in range(b,r+1):
if not Cs[j] in st and Cs[j] in dic:
bt.add(dic[Cs[j]],-1)
st.add(Cs[j])
dic[Cs[j]] = j
for s in st:
bt.add(dic[s], 1)
b = r + 1
ans[i] = bt.sum(r) - bt.sum(l-1)
for a in ans:
print(a) | p02599 |
#https://qiita.com/takayg1/items/c811bd07c21923d7ec69
#####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
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
q = []
for k in range(Q):
l, r = list(map(int, input().split()))
l -= 1
r -= 1
q.append([l, r, k])
q.sort(key = lambda x: x[1])
ans = [0 for k in range(Q)]
good = [0 for _ in range(N)]
good = SegTree(good, segfunc, ide_ele)
lastapp = [-1 for _ in range(N)]
end = -1
for k in range(Q):
l = q[k][0]
r = q[k][1]
a = q[k][2]
for j in range(r, end, -1):
if lastapp[c[j]-1] == -1:
lastapp[c[j]-1] = j
good.update(j, 1)
elif lastapp[c[j]-1] < j:
good.update(lastapp[c[j]-1], 0)
good.update(j, 1)
lastapp[c[j]-1] = j
ans[a] = good.query(l, r+1)
end = r
for k in range(Q):
print((ans[k])) | # Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
self.el = [0]*(n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
i += 1
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
q = []
for k in range(Q):
l, r = list(map(int, input().split()))
l -= 1
r -= 1
q.append([l, r, k])
q.sort(key = lambda x: x[1])
ans = [0 for k in range(Q)]
good = BIT(N)
lastapp = [-1 for _ in range(N)]
end = -1
for k in range(Q):
l = q[k][0]
r = q[k][1]
a = q[k][2]
for j in range(r, end, -1):
if lastapp[c[j]-1] == -1:
lastapp[c[j]-1] = j
good.add(j, 1)
elif lastapp[c[j]-1] < j:
good.add(lastapp[c[j]-1], -1)
good.add(j, 1)
lastapp[c[j]-1] = j
ans[a] = good.get(l, r+1)
end = r
for k in range(Q):
print((ans[k])) | p02599 |
from collections import Counter
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
cs = []
counter = Counter()
for ci in c:
counter.update([ci])
c2 = Counter(counter)
cs.append(c2)
memo = [[-1] * (N+1) for _ in range(N+1)]
for i in range(Q):
l, r = list(map(int, input().split()))
if memo[l][r] != -1:
print((memo[l][r]))
else:
c3 = Counter(cs[r-1])
if l > 1:
c3.subtract(cs[l-2])
c3 = +c3
memo[l][r] = len(c3)
print((memo[l][r]))
| import math
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
M = int(math.sqrt(N))
cs = []
for i in range(0, N, M):
cs.append(set(c[i:min(i+M, N)]))
for i in range(Q):
l, r = list(map(int, input().split()))
li = l // M
ri = r // M
if li == ri:
ans = len(set(c[l-1:r]))
else:
s = set(c[l-1:(li+1)*M])
for j in range(li+1, ri):
s.update(cs[j])
s.update(c[ri*M:r])
ans = len(s)
print(ans) | p02599 |
import math
N, Q = list(map(int, input().split()))
c = list(map(int, input().split()))
M = int(math.sqrt(N))
cs = []
for i in range(0, N, M):
cs.append(set(c[i:min(i+M, N)]))
for i in range(Q):
l, r = list(map(int, input().split()))
li = l // M
ri = r // M
if li == ri:
ans = len(set(c[l-1:r]))
else:
s = set(c[l-1:(li+1)*M])
for j in range(li+1, ri):
s.update(cs[j])
s.update(c[ri*M:r])
ans = len(s)
print(ans) | class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n+1)
def sum(self, i): # sum in [0, i)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x): # i > 0
assert i > 0
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-1, r-1, i])
lr.sort(key=lambda x: x[1])
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)
while current_q < Q and lr[current_q][1] == i:
ans[lr[current_q][2]] = bit.sum(lr[current_q][1] + 1) - bit.sum(lr[current_q][0])
current_q += 1
for i in range(Q):
print((ans[i]))
| p02599 |
def query(i):
'''
a[0] + a[1] + … + a[i-1] を求める
O(logN)
'''
res = 0
while i > 0:
res += BIT[i]
i -= i & -i
return res
def update(i, x):
'''
a[i-1]にxを加算
O(logN)
'''
while i <= n:
BIT[i] += x
i += i & -i
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query_ = [list(map(int, input().split())) + [i] for i in range(q)]
query_.sort(key=lambda x: x[1])
res = [0] * q
pos = [-1] * n
BIT = [0] * (n+1)
p = 0
for l, r, idx in query_:
for i in range(p, r):
if pos[c[i]-1] != -1:
update(pos[c[i]-1]+1, -1)
update(i+1, 1)
pos[c[i]-1] = i
res[idx] = query(r) - query(l-1)
p = r
for v in res:
print(v) | import sys
input = sys.stdin.readline
def query(i):
'''
a[0] + a[1] + … + a[i-1] を求める
O(logN)
'''
res = 0
while i > 0:
res += BIT[i]
i -= i & -i
return res
def update(i, x):
'''
a[i-1]にxを加算
O(logN)
'''
while i <= n:
BIT[i] += x
i += i & -i
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query_ = [list(map(int, input().split())) + [i] for i in range(q)]
query_.sort(key=lambda x: x[1])
res = [0] * q
pos = [-1] * n
BIT = [0] * (n+1)
p = 0
for l, r, idx in query_:
for i in range(p, r):
if pos[c[i]-1] != -1:
update(pos[c[i]-1]+1, -1)
update(i+1, 1)
pos[c[i]-1] = i
res[idx] = query(r) - query(l-1)
p = r
for v in res:
print(v) | p02599 |
import sys
input = sys.stdin.readline
def query(i):
'''
a[0] + a[1] + … + a[i-1] を求める
O(logN)
'''
res = 0
while i > 0:
res += BIT[i]
i -= i & -i
return res
def update(i, x):
'''
a[i-1]にxを加算
O(logN)
'''
while i <= n:
BIT[i] += x
i += i & -i
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query_ = [list(map(int, input().split())) + [i] for i in range(q)]
query_.sort(key=lambda x: x[1])
res = [0] * q
pos = [-1] * n
BIT = [0] * (n+1)
p = 0
for l, r, idx in query_:
for i in range(p, r):
if pos[c[i]-1] != -1:
update(pos[c[i]-1]+1, -1)
update(i+1, 1)
pos[c[i]-1] = i
res[idx] = query(r) - query(l-1)
p = r
for v in res:
print(v) | import sys
input = sys.stdin.buffer.readline
def query(i):
'''
a[0] + a[1] + … + a[i-1] を求める
O(logN)
'''
res = 0
while i > 0:
res += BIT[i]
i -= i & -i
return res
def update(i, x):
'''
a[i-1]にxを加算
O(logN)
'''
while i <= n:
BIT[i] += x
i += i & -i
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query_ = [list(map(int, input().split())) + [i] for i in range(q)]
query_.sort(key=lambda x: x[1])
res = [0] * q
pos = [-1] * n
BIT = [0] * (n+1)
p = 0
for l, r, idx in query_:
for i in range(p, r):
if pos[c[i]-1] != -1:
update(pos[c[i]-1]+1, -1)
update(i+1, 1)
pos[c[i]-1] = i
res[idx] = query(r) - query(l-1)
p = r
for v in res:
print(v) | p02599 |
"""
Satwik_Tiwari ;) .
30th AUGUST , 2020 - SUNDAY
"""
#===============================================================================================
#importing some useful libraries.
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return list(map(int, inp().split()))
def strsep(): return list(map(str, inp().split()))
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def solve(case):
n,q = sep()
c = lis()
bsize = floor(n**0.5)
blocks = [ceil(n/bsize)]
query = []
for i in range(q):
l,r = sep()
l-=1
r-=1
query.append((l//bsize,r,l,i))
query = sorted(query)
ans = [0]*(q)
currl = 0
currr = 0
prev = 1
have = {c[0]:1}
# print(query)
for i in range(q):
l = query[i][2]
r = query[i][1]
# print(l,r)
# print(currl,currr,prev)
# print(have)
while(currr<r):
currr+=1
if(c[currr] not in have):
have[c[currr]] = 1
prev+=1
else:
have[c[currr]] +=1
while(currr>r):
if(have[c[currr]]==1):
prev-=1
del have[c[currr]]
else:
have[c[currr]]-=1
currr-=1
while(currl>l):
currl-=1
if(c[currl] not in have):
have[c[currl]] = 1
prev+=1
else:
have[c[currl]] +=1
while(currl<l):
if(have[c[currl]] == 1):
prev-=1
del have[c[currl]]
else:
have[c[currl]]-=1
currl+=1
ans[query[i][3]]= prev
for i in range(len(ans)):
print(ans[i])
testcase(1)
# testcase(int(inp()))
| MAX = 1000001
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
if __name__ == "__main__":
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
# n = len(a)
queries = []
for i in range(q):
l,r = list(map(int,input().split()))
queries.append(Query(l-1,r-1,i))
# queries = [Query(0, 4, 0),
# Query(1, 3, 1),
# Query(2, 4, 2)]
# q = len(queries)
queries.sort(key = lambda x: x.r)
answeringQueries(a, n, queries, q)
| p02599 |
"""
Satwik_Tiwari ;) .
12th Sept , 2020 - Saturday
"""
#===============================================================================================
#importing some useful libraries.
# from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
# import bisect
# from heapq import *
# from math import *
# from copy import *
# from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
# from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
# from bisect import bisect_right as br
# from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
# from types import GeneratorType
# def iterative(f, stack=[]):
# def wrapped_func(*args, **kwargs):
# if stack: return f(*args, **kwargs)
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# continue
# stack.pop()
# if not stack: break
# to = stack[-1].send(to)
# return to
# return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return list(map(int, inp().split()))
def strsep(): return list(map(str, inp().split()))
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def solve(case):
n,q = sep()
c = lis()
query = []
for i in range(q):
l,r = sep()
query.append([r,l,i])
query.sort()
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind][0] == i+1):
ans[query[ind][2]] = (bit.sum(i+1) - bit.sum(query[ind][1]-1))
ind+=1
print('\n'.join(str(ans[i]) for i in range(len(ans))))
testcase(1)
# testcase(int(inp()))
| class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
class Query:
def __init__(self, r,l, idx):
self.l = l
self.r = r
self.idx = idx
def solve(case):
n,q = list(map(int,input().split()))
c = list(map(int,input().split()))
query = []
for i in range(q):
l,r = list(map(int,input().split()))
query.append(Query(r,l,i))
query.sort(key = lambda x:x.r)
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind].r == i+1):
ans[query[ind].idx] = (bit.sum(i+1) - bit.sum(query[ind].l-1))
ind+=1
print(('\n'.join(str(ans[i]) for i in range(len(ans)))))
solve(1)
| p02599 |
class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
class Query:
def __init__(self, r,l, idx):
self.l = l
self.r = r
self.idx = idx
def solve(case):
n,q = list(map(int,input().split()))
c = list(map(int,input().split()))
query = []
for i in range(q):
l,r = list(map(int,input().split()))
query.append(Query(r,l,i))
query.sort(key = lambda x:x.r)
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind].r == i+1):
ans[query[ind].idx] = (bit.sum(i+1) - bit.sum(query[ind].l-1))
ind+=1
# print('\n'.join(str(ans[i]) for i in range(len(ans))))
for i in range(q):
print((ans[i]))
solve(1)
| class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
class Query:
def __init__(self, r,l, idx):
self.l = l
self.r = r
self.idx = idx
def solve(case):
n,q = list(map(int,input().split()))
c = list(map(int,input().split()))
query = []
for i in range(q):
l,r = list(map(int,input().split()))
query.append(Query(r,l,i))
query.sort(key = lambda x:x.r)
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind].r == i+1):
ans[query[ind].idx] = (bit.sum(i+1) - bit.sum(query[ind].l-1))
ind+=1
print(('\n'.join(str(ans[i]) for i in range(len(ans)))))
# for i in range(q):
# print(ans[i])
solve(1)
| p02599 |
"""
Satwik_Tiwari ;) .
12th Sept , 2020 - Saturday
"""
#===============================================================================================
#importing some useful libraries.
# from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
# import bisect
# from heapq import *
# from math import *
# from copy import *
# from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
# from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
# from bisect import bisect_right as br
# from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
# from types import GeneratorType
# def iterative(f, stack=[]):
# def wrapped_func(*args, **kwargs):
# if stack: return f(*args, **kwargs)
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# continue
# stack.pop()
# if not stack: break
# to = stack[-1].send(to)
# return to
# return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return list(map(int, inp().split()))
def strsep(): return list(map(str, inp().split()))
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def solve(case):
n,q = sep()
c = lis()
query = []
for i in range(q):
l,r = sep()
query.append((r,l,i))
query = sorted(query)
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind][0] == i+1):
ans[query[ind][2]] = (bit.sum(i+1) - bit.sum(query[ind][1]-1))
ind+=1
print('\n'.join(str(ans[i]) for i in range(len(ans))))
testcase(1)
# testcase(int(inp()))
| """
Satwik_Tiwari ;) .
12th Sept , 2020 - Saturday
"""
#===============================================================================================
#importing some useful libraries.
# from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
# import bisect
# from heapq import *
# from math import *
# from copy import *
# from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
# from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
# from bisect import bisect_right as br
# from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
# from types import GeneratorType
# def iterative(f, stack=[]):
# def wrapped_func(*args, **kwargs):
# if stack: return f(*args, **kwargs)
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# continue
# stack.pop()
# if not stack: break
# to = stack[-1].send(to)
# return to
# return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return list(map(int, inp().split()))
def strsep(): return list(map(str, inp().split()))
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
class Query:
def __init__(self, r,l, idx):
self.l = l
self.r = r
self.idx = idx
def solve(case):
n,q = sep()
c = lis()
query = []
for i in range(q):
l,r = sep()
query.append(Query(r,l,i))
query = sorted(query,key=lambda x:x.r)
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind].r == i+1):
ans[query[ind].idx] = (bit.sum(i+1) - bit.sum(query[ind].l-1))
ind+=1
print('\n'.join(str(ans[i]) for i in range(len(ans))))
testcase(1)
# testcase(int(inp()))
| p02599 |
"""
Satwik_Tiwari ;) .
12th Sept , 2020 - Saturday
"""
#===============================================================================================
#importing some useful libraries.
# from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
# import bisect
# from heapq import *
# from math import *
# from copy import *
# from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
# from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
# from bisect import bisect_right as br
# from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
# from types import GeneratorType
# def iterative(f, stack=[]):
# def wrapped_func(*args, **kwargs):
# if stack: return f(*args, **kwargs)
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# continue
# stack.pop()
# if not stack: break
# to = stack[-1].send(to)
# return to
# return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return list(map(int, inp().split()))
def strsep(): return list(map(str, inp().split()))
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def solve(case):
n,q = sep()
c = lis()
query = []
for i in range(q):
l,r = sep()
query.append((r,l,i))
query = sorted(query)
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind][0] == i+1):
ans[query[ind][2]] = (bit.sum(i+1) - bit.sum(query[ind][1]-1))
ind+=1
print('\n'.join(str(ans[i]) for i in range(len(ans))))
testcase(1)
# testcase(int(inp()))
| """
Satwik_Tiwari ;) .
12th Sept , 2020 - Saturday
"""
#===============================================================================================
#importing some useful libraries.
# from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
# import bisect
# from heapq import *
# from math import *
# from copy import *
# from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
# from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
# from bisect import bisect_right as br
# from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
# from types import GeneratorType
# def iterative(f, stack=[]):
# def wrapped_func(*args, **kwargs):
# if stack: return f(*args, **kwargs)
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# continue
# stack.pop()
# if not stack: break
# to = stack[-1].send(to)
# return to
# return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return list(map(int, inp().split()))
def strsep(): return list(map(str, inp().split()))
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
class BIT:
def __init__(self,n):
self.n = n
self.tree = [0]*(n+1)
def sum(self,x):
sum = 0
while(x>0):
sum+=self.tree[x]
x-=x&(-x)
return sum
def update(self,x,k):
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def build(self,a):
for i in range(len(a)):
k = a[i]
x = i+1
while(x<=self.n):
self.tree[x]+=k
x+=x&(-x)
def solve(case):
n,q = sep()
c = lis()
query = []
for i in range(q):
l,r = sep()
query.append((r,l,i))
query = sorted(query,key=lambda x:x[0])
bit = BIT(n)
lastvis = [-1]*(n+1)
ind = 0
ans = [0]*q
for i in range(n):
if(lastvis[c[i]] != -1):
bit.update(lastvis[c[i]]+1,-1)
lastvis[c[i]] = i
bit.update(i+1,1)
while(ind<q and query[ind][0] == i+1):
ans[query[ind][2]] = (bit.sum(i+1) - bit.sum(query[ind][1]-1))
ind+=1
print('\n'.join(str(ans[i]) for i in range(len(ans))))
testcase(1)
# testcase(int(inp()))
| p02599 |
class FenwickTree:
def __init__(self, size):
self.size = size
self.array = [0]*size
def add(self, index, value):
while index < self.size:
self.array[index] += value
index += index&(-index)
def sum(self, index):
answer = 0
while index > 0:
answer += self.array[index]
index -= index&(-index)
return answer
def rangesum(self, start, end):
return self.sum(end)-self.sum(start-1)
def solve():
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
tree2 = FenwickTree(N+1)
m = [tuple(map(int, input().split())) for _ in range(Q)]
idxs = sorted(tuple(range(Q)), key=lambda i: m[i][1])
right = 0
pos = [-1] * (N+1)
ans = [-1] * (Q)
for idx in idxs:
l, r = m[idx]
for i in range(right, r):
x = pos[c[i]]
if x != -1:
tree2.add(x, -1)
pos[c[i]] = i+1
tree2.add(i+1, 1)
ans[idx] = tree2.rangesum(l, r)
right = r
for i in ans:
print(i)
if __name__ == '__main__':
solve()
| def solve():
import sys
input = sys.stdin.readline
class FenwickTree:
def __init__(self, size):
self.size = size
self.array = [0]*size
def add(self, index, value):
while index < self.size:
self.array[index] += value
index += index&(-index)
def sum(self, index):
answer = 0
while index > 0:
answer += self.array[index]
index -= index&(-index)
return answer
def rangesum(self, start, end):
return self.sum(end)-self.sum(start-1)
N, Q = list(map(int, input().split()))
*c, = list(map(int, input().split()))
tree2 = FenwickTree(N+1)
m = [tuple(map(int, input().split())) for _ in range(Q)]
idxs = sorted(tuple(range(Q)), key=lambda i: m[i][1])
right = 0
pos = [-1] * (N+1)
ans = [-1] * (Q)
for idx in idxs:
l, r = m[idx]
for i in range(right, r):
x = pos[c[i]]
if x != -1:
tree2.add(x, -1)
pos[c[i]] = i+1
tree2.add(i+1, 1)
ans[idx] = tree2.rangesum(l, r)
right = r
for i in ans:
print(i)
solve()
| p02599 |
from collections import deque, defaultdict
n, q = list(map(int ,input().split()))
c = list(map(int, input().split()))
data = []
for i in range(q):
data.append([i] + list(map(int, input().split())))
data.sort(key=lambda x : x[2])
ans = [0 for i in range(q)]
#####segfunc######
def segfunc(x,y):
return x + y
def init(init_val):
#set_val
for i in range(len(init_val)):
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 = 2**(n-1).bit_length()
seg=[ide_ele]*(2*num - 1)
good_ball = dict()
pre_r = 0
count = 0
for i in range(q):
index, l, r = data[i]
l, r = l-1, r-1
for j in range(pre_r, r+1):
if c[j] in good_ball :
update(good_ball[c[j]], 0)
update(j, 1)
good_ball[c[j]] = j
pre_r = r + 1
ans[index] = query(l, r+1)
for i in range(q):
print((ans[i])) | from sys import stdin
input = stdin.readline
n, q = list(map(int ,input().split()))
c = list(map(int, input().split()))
data = []
for i in range(q):
data.append([i] + list(map(int, input().split())))
data.sort(key=lambda x : x[2])
ans = [0 for i in range(q)]
#####segfunc######
def segfunc(x,y):
return x + y
def init(init_val):
#set_val
for i in range(len(init_val)):
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 = 2**(n-1).bit_length()
seg=[ide_ele]*(2*num - 1)
good_ball = dict()
pre_r = 0
count = 0
for i in range(q):
index, l, r = data[i]
l, r = l-1, r-1
for j in range(pre_r, r+1):
if c[j] in good_ball:
update(good_ball[c[j]], 0)
update(j, 1)
good_ball[c[j]] = j
pre_r = r + 1
ans[index] = query(l, r+1)
for i in range(q):
print((ans[i])) | p02599 |
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((i, l, r))
query.sort(key = lambda x: x[2])
class BIT:
from operator import add, sub
X_unit = 0
X_f = add
X_f_rev = sub
def __init__(self, seq):
N = len(seq)
self.N = N
self.X = seq[:]
for i in range(self.N):
j = i + ((i+1) & -(i+1))
if j < self.N:
self.X[j] = self.X_f(self.X[i], self.X[j])
def set_val(self, i, x):
while(i < self.N):
self.X[i] = self.X_f(self.X[i], x)
i += (i+1) & -(i+1)
def cum_val(self, i):
res = self.X_unit
while(i > -1):
res = self.X_f(res, self.X[i])
i -= (i+1) & -(i+1)
return res
#区間[L, R)
def fold(self, L, R):
return self.X_f_rev(self.cum_val(R-1), self.cum_val(L-1))
GJ = [-1]*N
bit = BIT([0]*N)
ans = [0]*Q
st = 0
for i in range(N):
if GJ[C[i]-1] != -1:
bit.set_val(GJ[C[i]-1], -1)
GJ[C[i]-1] = i
bit.set_val(i, 1)
while query[st][2] == i+1 and st < Q:
ans[query[st][0]] = bit.fold(query[st][1]-1, query[st][2])
st += 1
if st == Q:
break
print(*ans, sep="\n")
| import sys
input = sys.stdin.readline
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((i, l, r))
query.sort(key = lambda x: x[2])
class BIT:
from operator import add, sub
X_unit = 0
X_f = add
X_f_rev = sub
def __init__(self, seq):
N = len(seq)
self.N = N
self.X = seq[:]
for i in range(self.N):
j = i + ((i+1) & -(i+1))
if j < self.N:
self.X[j] = self.X_f(self.X[i], self.X[j])
def set_val(self, i, x):
while(i < self.N):
self.X[i] = self.X_f(self.X[i], x)
i += (i+1) & -(i+1)
def cum_val(self, i):
res = self.X_unit
while(i > -1):
res = self.X_f(res, self.X[i])
i -= (i+1) & -(i+1)
return res
def fold(self, L, R):
return self.X_f_rev(self.cum_val(R-1), self.cum_val(L-1))
GJ = [-1]*N
bit = BIT([0]*N)
ans = [0]*Q
st = 0
for i in range(N):
if GJ[C[i]-1] != -1:
bit.set_val(GJ[C[i]-1], -1)
GJ[C[i]-1] = i
bit.set_val(i, 1)
if st < Q:
while query[st][2] == i+1:
ans[query[st][0]] = bit.fold(query[st][1]-1, query[st][2])
st += 1
if st == Q:
break
print(*ans, sep="\n")
| p02599 |
import sys
input = sys.stdin.readline
def update(index, value, bit):
#print('update', index, value)
while index < len(bit):
#print('update', index)
bit[index] += value
index += index & -index
#print('done')
def cumsum(index, bit):
ans = 0
while index > 0:
#print('cumsum', index)
ans += bit[index]
index -= index & -index
#print('done', ans)
return ans
def main():
N, q = [int(x) for x in input().split()]
C = [int(x)-1 for x in input().split()]
Q = []
for _ in range(q):
Q.append(tuple(int(x)-1 for x in input().split()[::-1]))
I = sorted(list(range(q)), key=Q.__getitem__)
#print(I, Q)
leftmost = [-1] * N
bit = [0] * (N+1)
prev = -1
ans = [0] * q
for i in I:
r, l = Q[i]
#print(i, r, l)
to_update = {}
for x in range(prev+1, r+1):
to_update[C[x]] = x
for c, x in list(to_update.items()):
if leftmost[c] >= 0:
update(leftmost[c] + 1, -1, bit)
leftmost[c] = x
update(x + 1, 1, bit)
prev = r
#print(i, r, l)
#print(C)
#print([cumsum(i, bit) for i in range(1, N+1)])
ans[i] = cumsum(r + 1, bit) - cumsum(l, bit)
for a in ans:
print(a)
main() |
import sys
input = sys.stdin.readline
def update(index, value, bit):
#print('update', index, value)
while index < len(bit):
#print('update', index)
bit[index] += value
index += index & -index
#print('done')
def cumsum(index, bit):
ans = 0
while index > 0:
#print('cumsum', index)
ans += bit[index]
index -= index & -index
#print('done', ans)
return ans
def main():
N, q = [int(x) for x in input().split()]
C = [int(x)-1 for x in input().split()]
Q = []
for i in range(q):
l, r = [int(x)-1 for x in input().split()]
Q.append((i, l, r))
Q.sort(key=lambda x: x[2])
leftmost = [-1] * N
bit = [0] * (N+1)
prev = -1
ans = [0] * q
for i, l, r in Q:
#print(i, r, l)
to_update = {}
for x in range(prev+1, r+1):
to_update[C[x]] = x
for c, x in list(to_update.items()):
if leftmost[c] >= 0:
update(leftmost[c] + 1, -1, bit)
leftmost[c] = x
update(x + 1, 1, bit)
prev = r
#print(i, r, l)
#print(C)
#print([cumsum(i, bit) for i in range(1, N+1)])
ans[i] = cumsum(r + 1, bit) - cumsum(l, bit)
for a in ans:
print(a)
main() | p02599 |
import sys
input = sys.stdin.readline
def main():
n,q=map(int,input().split())
c=list(map(int,input().split()))
lr=[list(map(int,input().split())) for _ in range(q)]
lri=[[lr[i][0],lr[i][1],i] for i in range(q)]
lri.sort(key=lambda x:x[1])
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=segfunc, ide_ele=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
st=SegTree([0]*(n+1))
dc={}
ans=[0]*q
j=0
for i in range(n):
x=c[i]
if x in dc:
st.update(dc[x],0)
st.update(i+1,1)
dc[x]=i+1
while j<q and i+1==lri[j][1]:
l,r,k=lri[j]
ans[k]=st.query(l,r+1)
j+=1
if j==q:break
print(*ans,sep='\n')
if __name__=='__main__':
#import datetime
#print(datetime.datetime.now())
main()
#print(datetime.datetime.now())
|
import sys
input = sys.stdin.readline
def main():
n,q=map(int,input().split())
c=list(map(int,input().split()))
lr=[list(map(int,input().split())) for _ in range(q)]
lri=[[lr[i][0],lr[i][1],i] for i in range(q)]
lri.sort(key=lambda x:x[1])
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)
bt=BIT(n+1)
dc={}
ans=[0]*q
j=0
for i in range(n):
x=c[i]
if x in dc:
bt.add(dc[x],-1)
bt.add(i+1,1)
dc[x]=i+1
while j<q and i+1==lri[j][1]:
l,r,k=lri[j]
ans[k]=bt.get(l-1,r)
j+=1
if j==q:break
print(*ans,sep='\n')
if __name__=='__main__':
#import datetime
#print(datetime.datetime.now())
main()
#print(datetime.datetime.now())
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=list(map(int1,input().split()))
lr=[]
for i in range(Q):
l,r=map(int1,input().split())
lr.append((l,r,i))
lr.sort(key=lambda t: t[1],reverse=1)
class RangeBIT:
def __init__(self,n):
self.p=self.BIT(n+1)
self.q=self.BIT(n+1)
def add(self,s,t,x):
self.p.add(s,-x*s)
self.p.add(t,x*t)
self.q.add(s,x)
self.q.add(t,-x)
def sum(self,s,t):
return self.p.sum(t)+self.q.sum(t)*t-self.p.sum(s)-self.q.sum(s)*s
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
b=RangeBIT(N)
lastap=[-1]*N
ans=[-1]*Q
for i in range(N):
if lastap[a[i]]!=-1:
b.add(lastap[a[i]],lastap[a[i]]+1,-1)
b.add(i,i+1,1)
lastap[a[i]]=i
while lr and lr[-1][1]==i:
l,r,j=lr.pop()
ans[j]=b.sum(l,r+1)
for x in ans:
print(x)
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[[0,0,i] for i in range(Q)]
for i in range(Q):
lr[i][0],lr[i][1]=map(int1,input().split())
lr.sort(key=lambda t: t[1],reverse=1)
class RangeBIT:
def __init__(self,n):
self.p=self.BIT(n+1)
self.q=self.BIT(n+1)
def add(self,s,t,x):
self.p.add(s,-x*s)
self.p.add(t,x*t)
self.q.add(s,x)
self.q.add(t,-x)
def sum(self,s,t):
return self.p.sum(t)+self.q.sum(t)*t-self.p.sum(s)-self.q.sum(s)*s
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
b=RangeBIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i in range(N):
if lastap[a[i]]!=-1:
b.add(lastap[a[i]],lastap[a[i]]+1,-1)
b.add(i,i+1,1)
lastap[a[i]]=i
while r==i:
ans[j]=b.sum(l,r+1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[[0,0,i] for i in range(Q)]
for i in range(Q):
lr[i][0],lr[i][1]=map(int1,input().split())
lr.sort(key=lambda t: t[1],reverse=1)
class RangeBIT:
def __init__(self,n):
self.p=self.BIT(n+1)
self.q=self.BIT(n+1)
def add(self,s,t,x):
self.p.add(s,-x*s)
self.p.add(t,x*t)
self.q.add(s,x)
self.q.add(t,-x)
def sum(self,s,t):
return self.p.sum(t)+self.q.sum(t)*t-self.p.sum(s)-self.q.sum(s)*s
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
b=RangeBIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i in range(N):
if lastap[a[i]]!=-1:
b.add(lastap[a[i]],lastap[a[i]]+1,-1)
b.add(i,i+1,1)
lastap[a[i]]=i
while r==i:
ans[j]=b.sum(l,r+1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[[0,0,i] for i in range(Q)]
for i in range(Q):
lr[i][0],lr[i][1]=map(int1,input().split())
lr.sort(key=lambda t: t[1],reverse=1)
class RangeBIT:
def __init__(self,n):
self.p=self.BIT(n+1)
self.q=self.BIT(n+1)
def add(self,s,t,x):
self.p.add(s,-x*s)
self.p.add(t,x*t)
self.q.add(s,x)
self.q.add(t,-x)
def sum(self,s,t):
return self.p.sum(t)+self.q.sum(t)*t-self.p.sum(s)-self.q.sum(s)*s
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
b=RangeBIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],lastap[x]+1,-1)
b.add(i,i+1,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(l,r+1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[[0,0,i] for i in range(Q)]
for i in range(Q):
lr[i][0],lr[i][1]=map(int1,input().split())
lr.sort(key=lambda t: t[1],reverse=1)
class RangeBIT:
def __init__(self,n):
self.p=self.BIT(n+1)
self.q=self.BIT(n+1)
def add(self,s,t,x):
self.p.add(s,-x*s)
self.p.add(t,x*t)
self.q.add(s,x)
self.q.add(t,-x)
def sum(self,s,t):
return self.p.sum(t)+self.q.sum(t)*t-self.p.sum(s)-self.q.sum(s)*s
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
b=RangeBIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],lastap[x]+1,-1)
b.add(i,i+1,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(l,r+1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[[0,0,i] for i in range(Q)]
for i in range(Q):
lr[i][0],lr[i][1]=map(int1,input().split())
lr.sort(key=lambda t: t[1],reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[[0,0,i] for i in range(Q)]
for i in range(Q):
lr[i][0],lr[i][1]=map(int1,input().split())
lr.sort(key=lambda t: t[1],reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[() for i in range(Q)]
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=(l,r,i)
lr.sort(key=lambda t: t[1],reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[() for i in range(Q)]
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=(l,r,i)
lr.sort(key=lambda t: t[1],reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
for x in ans:
print(x)
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[() for i in range(Q)]
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=(l,r,i)
lr.sort(key=lambda t: t[1],reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
print(*ans,sep='\n')
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[() for i in range(Q)]
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=(l,r,i)
lr.sort(key=lambda t: t[1],reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
l,r,j=lr.pop()
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
l,r,j=lr.pop()
else:
l,r,j=-1,-1,-1
print(*ans,sep='\n')
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[0]*Q
c0=10**12
c1=10**6
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=r*c0+l*c1+i
lr.sort(reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
lrj=lr.pop()
r=lrj//c0
lrj%=c0
l=lrj//c1
j=lrj%c1
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
lrj=lr.pop()
r=lrj//c0
lrj%=c0
l=lrj//c1
j=lrj%c1
else:
l,r,j=-1,-1,-1
print(*ans,sep='\n')
| p02599 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[0]*Q
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=(r<<40)+(l<<20)+i
lr.sort(reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
mask=(1<<20)-1
lrj=lr.pop()
j=lrj&mask
lrj>>=20
l=lrj&mask
r=lrj>>20
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
lrj=lr.pop()
j=lrj&mask
lrj>>=20
l=lrj&mask
r=lrj>>20
else:
l,r,j=-1,-1,-1
print(*ans,sep='\n')
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
N,Q=map(int,input().split())
a=tuple(map(int1,input().split()))
lr=[0]*Q
for i in range(Q):
l,r=map(int1,input().split())
lr[i]=(r<<40)+(l<<20)+i
lr.sort(reverse=1)
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
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
b=BIT(N)
lastap=[-1]*N
ans=[-1]*Q
mask=(1<<20)-1
lr_pop=lr.pop
lrj=lr_pop()
j=lrj&mask
lrj>>=20
l=lrj&mask
r=lrj>>20
for i,x in enumerate(a):
if lastap[x]!=-1:
b.add(lastap[x],-1)
b.add(i,1)
lastap[x]=i
while r==i:
ans[j]=b.sum(r)-b.sum(l-1)
if lr:
lrj=lr_pop()
j=lrj&mask
lrj>>=20
l=lrj&mask
r=lrj>>20
else:
l,r,j=-1,-1,-1
print(*ans,sep='\n')
| p02599 |
import sys
class BinaryIndexedTree(object):
'''
1-indexed
'''
def __init__(self, A):
self.__n = len(A)
self.__node = [0] * (self.__n + 1)
self.__data = [0] * (self.__n + 1)
S = [0] * (self.__n + 1)
for i in range(self.__n):
S[i + 1] = S[i] + A[i]
for i in range(1, self.__n + 1):
self.__data[i] = A[i - 1]
self.__node[i] = S[i] - S[i - (i & -i)]
def add(self, i, v):
self.__data[i] += v
while i <= self.__n:
self.__node[i] += v
i += i & -i
def sum(self, i):
''' [1, i]の和
'''
rst = 0
while i > 0:
rst += self.__node[i]
i -= i & -i
return rst
def get(self, i, j):
'''[i, j]の和
'''
if i == j:
return self.__data[i]
else:
return self.sum(j) - self.sum(i - 1)
def main():
N, Q = map(int, input().split())
C = list(map(int, input().split()))
P = [[] for _ in range(N)]
for i, c in enumerate(C):
P[c - 1].append(i)
right = [0] * N
for p in P:
if len(p):
right[p.pop()] = 1
BIT = BinaryIndexedTree(right)
query = []
for i in range(Q):
l, r = map(int, sys.stdin.readline().split())
query.append((r - 1, l - 1, i))
query.sort(reverse=True)
ans = [None] * Q
cur = N - 1
for r, l, i in query:
while r < cur:
c = C[cur] - 1
# BIT.update(cur + 1, 0)
p = P[c]
if len(p):
BIT.add(p.pop() + 1, 1)
cur -= 1
tmp = BIT.get(l + 1, r + 1)
ans[i] = tmp
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| import sys
class BinaryIndexedTree():
'''
1-indexed
'''
def __init__(self, A):
self.__n = len(A)
self.__node = [0] * (self.__n + 1)
self.__data = [0] * (self.__n + 1)
S = [0] * (self.__n + 1)
for i in range(self.__n):
S[i + 1] = S[i] + A[i]
for i in range(1, self.__n + 1):
self.__data[i] = A[i - 1]
self.__node[i] = S[i] - S[i - (i & -i)]
def add(self, i, v):
self.__data[i] += v
while i <= self.__n:
self.__node[i] += v
i += i & -i
def sum(self, i):
''' [1, i]の和
'''
rst = 0
while i > 0:
rst += self.__node[i]
i -= i & -i
return rst
def get(self, i, j):
'''[i, j]の和
'''
if i == j:
return self.__data[i]
else:
return self.sum(j) - self.sum(i - 1)
def main():
N, Q = map(int, input().split())
C = list(map(int, input().split()))
P = [[] for _ in range(N)]
for i, c in enumerate(C):
P[c - 1].append(i)
right = [0] * N
for p in P:
if len(p):
right[p.pop()] = 1
BIT = BinaryIndexedTree(right)
query = [[] for _ in range(N)]
for i in range(Q):
l, r = map(int, sys.stdin.readline().split())
query[r - 1].append((l - 1, i))
ans = [None] * Q
cur = N - 1
for r, q in enumerate(reversed(query)):
r = (N - 1) - r
while q:
l, i = q.pop()
while r < cur:
c = C[cur] - 1
# BIT.update(cur + 1, 0)
p = P[c]
if len(p):
BIT.add(p.pop() + 1, 1)
cur -= 1
tmp = BIT.get(l + 1, r + 1)
ans[i] = tmp
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| p02599 |
import sys
class BinaryIndexedTree():
'''
1-indexed
'''
def __init__(self, A):
self.__n = len(A)
self.__node = [0] * (self.__n + 1)
self.__data = [0] * (self.__n + 1)
S = [0] * (self.__n + 1)
for i in range(1, self.__n + 1):
S[i] = S[i - 1] + A[i - 1]
self.__data[i] = A[i - 1]
self.__node[i] = S[i] - S[i - (i & -i)]
def add(self, i, v):
self.__data[i] += v
while i <= self.__n:
self.__node[i] += v
i += i & -i
def sum(self, i):
''' [1, i]の和
'''
rst = 0
while i > 0:
rst += self.__node[i]
i -= i & -i
return rst
def get(self, i, j):
'''[i, j]の和
'''
if i == j:
return self.__data[i]
else:
return self.sum(j) - self.sum(i - 1)
def main():
N, Q = map(int, input().split())
C = list(map(int, input().split()))
P = [[] for _ in range(N)]
for i, c in enumerate(C):
P[c - 1].append(i)
right = [0] * N
for p in P:
if len(p):
right[p.pop()] = 1
BIT = BinaryIndexedTree(right)
query = [[] for _ in range(N)]
for i, s in enumerate(sys.stdin.readlines()):
l, r = map(int, s.split())
query[r - 1].append((l - 1, i))
ans = [None] * Q
cur = N - 1
for r, q in enumerate(reversed(query)):
r = (N - 1) - r
while q:
l, i = q.pop()
while r < cur:
c = C[cur] - 1
p = P[c]
if len(p):
BIT.add(p.pop() + 1, 1)
cur -= 1
tmp = BIT.get(l + 1, r + 1)
ans[i] = tmp
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| import sys
class BinaryIndexedTree():
'''
1-indexed
'''
def __init__(self, A):
self.__n = len(A)
self.__node = [0] * (self.__n + 1)
self.__data = [0] * (self.__n + 1)
S = [0] * (self.__n + 1)
for i in range(self.__n):
S[i + 1] = S[i] + A[i]
for i in range(1, self.__n + 1):
self.__data[i] = A[i - 1]
self.__node[i] = S[i] - S[i - (i & -i)]
def add(self, i, v):
self.__data[i] += v
while i <= self.__n:
self.__node[i] += v
i += i & -i
def sum(self, i):
''' [1, i]の和
'''
rst = 0
while i > 0:
rst += self.__node[i]
i -= i & -i
return rst
def get(self, i, j):
'''[i, j]の和
'''
if i == j:
return self.__data[i]
else:
return self.sum(j) - self.sum(i - 1)
def main():
N, Q = map(int, input().split())
C = list(map(int, input().split()))
P = [[] for _ in range(N)]
for i, c in enumerate(C):
P[c - 1].append(i)
right = [0] * N
for p in P:
if len(p):
right[p.pop()] = 1
BIT = BinaryIndexedTree(right)
query = [[] for _ in range(N)]
for i, s in enumerate(sys.stdin.readlines()):
l, r = map(int, s.split())
query[r - 1].append((l - 1, i))
ans = [None] * Q
cur = N - 1
for r, q in enumerate(reversed(query)):
r = (N - 1) - r
while q:
l, i = q.pop()
while r < cur:
c = C[cur] - 1
p = P[c]
if len(p):
BIT.add(p.pop() + 1, 1)
cur -= 1
tmp = BIT.get(l + 1, r + 1)
ans[i] = tmp
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| p02599 |
import sys
from operator import add
class SegmentTree():
"""
update, get を提供するSegmentTree
Attributes
----------
__n : int
葉の数。2 ^ i - 1
__dot :
Segment function
__e: int
単位元
__node: list
Segment Tree
"""
def __init__(self, A, dot, e):
"""
Parameters
----------
A : list
対象の配列
dot :
Segment function
e : int
単位元
"""
n = 2 ** (len(A) - 1).bit_length()
self.__n = n
self.__dot = dot
self.__e = e
self.__node = [e] * (2 * n)
for i in range(len(A)):
self.__node[i + n] = A[i]
for i in range(n - 1, 0, -1):
self.__node[i] = self.__dot(self.__node[2 * i], self.__node[2 * i + 1])
def update(self, i, c):
i += self.__n
node = self.__node
node[i] = c
while i > 1:
i //= 2
node[i] = self.__dot(node[2 * i], node[2 * i + 1])
def get(self, l, r):
vl, vr = self.__e, self.__e
l += self.__n
r += self.__n
while (l < r):
if l & 1:
vl = self.__dot(vl, self.__node[l])
l += 1
l //= 2
if r & 1:
r -= 1
vr = self.__dot(vr, self.__node[r])
r //= 2
return self.__dot(vl, vr)
def main():
N, Q = map(int, input().split())
C = list(map(int, input().split()))
P = [[] for _ in range(N)]
for i, c in enumerate(C):
P[c - 1].append(i)
right = [0] * N
for p in P:
if len(p):
right[p.pop()] = 1
seg = SegmentTree(right, add, 0)
query = []
for i in range(Q):
l, r = map(int, sys.stdin.readline().split())
query.append((r - 1, l - 1, i))
query.sort(reverse=True)
ans = [None] * Q
cur = N - 1
for r, l, i in query:
while r < cur:
c = C[cur] - 1
# seg.update(cur, 0)
p = P[c]
if len(p):
seg.update(p.pop(), 1)
cur -= 1
tmp = seg.get(l, r + 1)
ans[i] = tmp
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| import sys
from operator import add, itemgetter
class SegmentTree():
"""
update, get を提供するSegmentTree
Attributes
----------
__n : int
葉の数。2 ^ i - 1
__dot :
Segment function
__e: int
単位元
__node: list
Segment Tree
"""
def __init__(self, A, dot, e):
"""
Parameters
----------
A : list
対象の配列
dot :
Segment function
e : int
単位元
"""
n = 2 ** (len(A) - 1).bit_length()
self.__n = n
self.__dot = dot
self.__e = e
self.__node = [e] * (2 * n)
for i in range(len(A)):
self.__node[i + n] = A[i]
for i in range(n - 1, 0, -1):
self.__node[i] = self.__dot(self.__node[2 * i], self.__node[2 * i + 1])
def update(self, i, c):
i += self.__n
node = self.__node
node[i] = c
while i > 1:
i //= 2
node[i] = self.__dot(node[2 * i], node[2 * i + 1])
def get(self, l, r):
vl, vr = self.__e, self.__e
l += self.__n
r += self.__n
while (l < r):
if l & 1:
vl = self.__dot(vl, self.__node[l])
l += 1
l //= 2
if r & 1:
r -= 1
vr = self.__dot(vr, self.__node[r])
r //= 2
return self.__dot(vl, vr)
def main():
N, Q = map(int, input().split())
C = list(map(int, input().split()))
P = [[] for _ in range(N)]
for i, c in enumerate(C):
P[c - 1].append(i)
right = [0] * N
for p in P:
if len(p):
right[p.pop()] = 1
seg = SegmentTree(right, add, 0)
query = []
for i in range(Q):
l, r = map(int, sys.stdin.readline().split())
query.append((r - 1, l - 1, i))
query.sort(reverse=True, key=itemgetter(0))
ans = [None] * Q
cur = N - 1
for r, l, i in query:
while r < cur:
c = C[cur] - 1
p = P[c]
if len(p):
seg.update(p.pop(), 1)
cur -= 1
tmp = seg.get(l, r + 1)
ans[i] = tmp
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| 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
import sys
input = sys.stdin.buffer.readline
n, q = list(map(int, input().split()))
clst = 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])
bit = Bit(n)
pos = 0
last = [-1 for _ in range(n)]
ans = []
for i, c in enumerate(clst):
bit.add(i + 1, 1)
if last[c - 1] != -1:
bit.add(last[c - 1] + 1, -1)
last[c - 1] = i
while lr[pos][1] == i + 1:
l = lr[pos][0]
r = lr[pos][1]
ans.append([bit.sum(r) - bit.sum(l - 1), lr[pos][2]])
pos += 1
if pos == q:
break
if pos == q:
break
ans.sort(key=lambda x:x[1])
for num, _ in ans:
print(num)
| 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
import sys
input = sys.stdin.buffer.readline
n, q = map(int, input().split())
clst = list(map(int, input().split()))
lr = []
for i in range(q):
l, r = map(int, input().split())
lr.append([l, r, i])
lr.sort(key=lambda x:x[1])
bit = Bit(n)
pos = 0
last = [-1 for _ in range(n)]
ans = [-1 for _ in range(q)]
for i, c in enumerate(clst):
bit.add(i + 1, 1)
if last[c - 1] != -1:
bit.add(last[c - 1] + 1, -1)
last[c - 1] = i
while lr[pos][1] == i + 1:
l = lr[pos][0]
r = lr[pos][1]
ans[lr[pos][2]] = bit.sum(r) - bit.sum(l - 1)
pos += 1
if pos == q:
break
if pos == q:
break
print(*ans, sep="\n")
| p02599 |
n, q = map(int, input().split())
C = [0] + list(map(int, input().split()))
D = [-1]*(n+1)
A = [0]*q
LR = tuple(tuple(map(int, input().split())) for _ in range(q))
W = sorted((r, i) for i, (l, r) in enumerate(LR))
B = [0]*(1<<n.bit_length())
def add(i, a):
while i <= n:
B[i] += a
i += i & -i
def acc(i):
res = 0
while i > 0:
res += B[i]
i -= i & -i
return res
temp = 1
for r, i in W:
while temp <= r:
c = C[temp]
add(temp, 1)
if D[c] != -1:
add(D[c], -1)
D[c] = temp
temp += 1
l = LR[i][0]
A[i] = acc(r) - acc(l-1)
print(*A, sep="\n")
| n, q = map(int, input().split())
C = [0] + list(map(int, input().split()))
D = [-1]*(n+1)
A = [0]*q
U = 10**6
LR = tuple(tuple(map(int, input().split())) for _ in range(q))
W = sorted(r*U+i for i, (l, r) in enumerate(LR))
B = [0]*(1<<n.bit_length())
def add(i, a):
while i <= n:
B[i] += a
i += i & -i
def acc(i):
res = 0
while i:
res += B[i]
i -= i & -i
return res
temp = 1
for w in W:
r, i = divmod(w, U)
while temp <= r:
c = C[temp]
add(temp, 1)
if D[c] != -1:
add(D[c], -1)
D[c] = temp
temp += 1
l = LR[i][0]
A[i] = acc(r) - acc(l-1)
print(*A, sep="\n")
| p02599 |
from collections import deque
N,Q=list(map(int, input().split()))
#重複分を引く
class SegmentTree:
def __init__(self, init_value: list, segfunc, ide_ele):
n = len(init_value)
self.N0 = 1 << (n - 1).bit_length()
self.ide_ele = ide_ele
self.data = [ide_ele] * (2 * self.N0)
self.segfunc = segfunc
for i, x in enumerate(init_value):
self.data[i + self.N0 - 1] = x
for i in range(self.N0 - 2, -1, -1):
self.data[i] = self.segfunc(self.data[2 * i + 1], self.data[2 * i + 2])
# k: index , x: value
def update(self, k: int, x):
k += self.N0 - 1
############################
self.data[k] = x
###########################
while k:
k = (k - 1) // 2
self.data[k] = self.segfunc(self.data[k * 2 + 1], self.data[k * 2 + 2])
# rightは開区間 l<=x<r
def query(self, left: int, right: int):
L = left + self.N0
R = right + self.N0
res = self.ide_ele
##########################
a, b = [], []
while L < R:
if L & 1:
a.append(L - 1)
L += 1
if R & 1:
R -= 1
b.append(R - 1)
L >>= 1
R >>= 1
for i in a + b[::-1]:
res = self.segfunc(res, self.data[i])
##########################
return res
C=list(map(int, input().split()))
state=[-1]*N
que=[]
for i in range(N):
c=C[i]
if state[c-1]==-1:
state[c-1]=i
else:
que.append((state[c-1],i))
state[c-1]=i
que=sorted(que, key=lambda x: x[1])
query=[]
for i in range(Q):
l, r=list(map(int, input().split()))
query.append((l-1,r-1,i))
query=sorted(query, key=lambda x: -x[1])
A=[0]*(N+1)
def add(a,b):
return a+b
seg=SegmentTree(A,add,0)
ans=[0]*Q
for i in range(len(que)):
while query and query[-1][1]<que[i][1]:
q=query.pop()
l,r,j=q
ans[j]=r-l+1-seg.query(l,r+1)
now=que[i]
l, r=now # index
A[l]+=1
seg.update(l, A[l])
while query and query[-1][1]==r:
q=query.pop()
lq,rq,j=q
ans[j]=rq-lq+1-seg.query(lq,rq+1)
#print(lq, rq, seg.query(lq,rq+1))
while query:
q=query.pop()
lq,rq,j=q
ans[j]=rq-lq+1-seg.query(lq,rq+1)
#print(lq, rq, seg.query(lq,rq+1))
for a in ans:
print(a) | from collections import deque
N,Q=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
# I: idx(base: 1), x: value
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
# i<=x<j
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
C=list(map(int, input().split()))
state=[-1]*N
que=[]
for i in range(N):
c=C[i]
if state[c-1]==-1:
state[c-1]=i+1
else:
que.append((state[c-1],i+1))
state[c-1]=i+1
que=sorted(que, key=lambda x: x[1])
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[1])
seg=BIT(N+1)
ans=[0]*Q
for i in range(len(que)):
while query and query[-1][1]<que[i][1]:
q=query.pop()
l,r,j=q
ans[j]=r-l+1-(seg.get(l-1,r))
now=que[i]
l, r=now # index
#A[l]+=1
seg.add(l, 1)
while query and query[-1][1]==r:
q=query.pop()
lq,rq,j=q
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
#print(seg.get(lq,rq+1))
while query:
q=query.pop()
lq,rq,j=q
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
for a in ans:
print(a)
| p02599 |
from collections import deque
N,Q=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
# I: idx(base: 1), x: value
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
# i<=x<j
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
C=list(map(int, input().split()))
state=[-1]*N
que=[]
for i in range(N):
c=C[i]
if state[c-1]==-1:
state[c-1]=i+1
else:
que.append((state[c-1],i+1))
state[c-1]=i+1
que=sorted(que, key=lambda x: x[1])
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[1])
seg=BIT(N+1)
ans=[0]*Q
for i in range(len(que)):
while query and query[-1][1]<que[i][1]:
q=query.pop()
l,r,j=q
ans[j]=r-l+1-(seg.get(l-1,r))
now=que[i]
l, r=now # index
#A[l]+=1
seg.add(l, 1)
while query and query[-1][1]==r:
q=query.pop()
lq,rq,j=q
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
#print(seg.get(lq,rq+1))
while query:
q=query.pop()
lq,rq,j=q
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
for a in ans:
print(a)
| from collections import deque
N,Q=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
# I: idx(base: 1), x: value
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
# i<=x<j
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
C=list(map(int, input().split()))
state=[-1]*N
que=[]
for i in range(N):
c=C[i]
if state[c-1]==-1:
state[c-1]=i+1
else:
que.append((state[c-1],i+1))
state[c-1]=i+1
que=sorted(que, key=lambda x: x[1])
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[1])
seg=BIT(N+1)
ans=[0]*Q
for i in range(len(que)):
while query and query[-1][1]<que[i][1]:
l,r,j=query.pop()
ans[j]=r-l+1-(seg.get(l-1,r))
now=que[i]
l, r=now # index
#A[l]+=1
seg.add(l, 1)
while query and query[-1][1]==r:
lq,rq,j=query.pop()
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
#print(seg.get(lq,rq+1))
while query:
lq,rq,j=query.pop()
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
for a in ans:
print(a)
| p02599 |
from collections import deque
N,Q=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
# I: idx(base: 1), x: value
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
# i<x<=j
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
query=[]
C=list(map(int, input().split()))
for i in range(Q):
l, r=list(map(int, input().split()))
query.append((l,r,i))
query=sorted(query, key=lambda x: -x[1])
state=[-1]*N
seg=BIT(N+1)
ans=[0]*Q
for i in range(N):
while query and query[-1][1]<i+1:
l,r,j=query.pop()
ans[j]=r-l+1-(seg.get(l-1,r))
c=C[i]
if state[c-1]==-1:
state[c-1]=i+1
else:
idx=state[c-1]
seg.add(idx,1)
state[c-1]=i+1
while query and query[-1][1]==i:
lq,rq,j=query.pop()
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.get(lq-1,rq))
while query:
lq,rq,j=query.pop()
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.query(lq,rq+1))
for a in ans:
print(a)
| from collections import deque
N,Q=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
# I: idx(base: 1), x: value
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
# i<x<=j
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
query=[]
C=list(map(int, input().split()))
for i in range(Q):
l, r=list(map(int, input().split()))
query.append((l,r,i))
query=sorted(query, key=lambda x: -x[1])
state=[-1]*N
seg=BIT(N+1)
ans=[0]*Q
for i in range(N):
while query and query[-1][1]<i+1:
l,r,j=query.pop()
ans[j]=r-l+1-(seg.get(l-1,r))
c=C[i]
if state[c-1]==-1:
state[c-1]=i+1
else:
idx=state[c-1]
seg.add(idx,1)
state[c-1]=i+1
while query and query[-1][1]==i+1:
lq,rq,j=query.pop()
ans[j]=rq-lq+1-(seg.get(lq-1,rq))
#print(lq, rq, seg.get(lq-1,rq))
for a in ans:
print(a)
| p02599 |
import sys
input = sys.stdin.buffer.readline
from operator import itemgetter
class BIT:
"""一点加算、区間取得クエリをそれぞれO(logN)で答えるデータ構造"""
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def build(self, array):
"""arrayを初期値とするBinaryIndexTreeを構築する O(N)"""
for i in range(self.size):
self.bit[i + 1] = array[i]
for i in range(1, self.size):
if i + (i & -i) > self.size:
continue
self.bit[i + (i & -i)] += self.bit[i]
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
"""i番目の要素にvalを加える"""
i += 1
while i <= self.size:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
"""区間[l, r)の和を求める"""
return self._sum(r) - self._sum(l)
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query = [list(map(int, input().split())) + [i] for i in range(q)]
bit = BIT(n)
memo = {}
ans = [0] * q
query = sorted(query, key=itemgetter(1))
ind = 0
for l, r, i in query:
while ind < r:
if c[ind] in memo:
old_ind = memo[c[ind]]
else:
old_ind = -1
memo[c[ind]] = ind
bit.add(ind, 1)
if old_ind != -1:
bit.add(old_ind, -1)
ind += 1
ans[i] = bit.get_sum(l - 1, r)
for i in range(q):
print((ans[i])) | import sys
input = sys.stdin.buffer.readline
from operator import itemgetter
class BIT:
"""一点加算、区間取得クエリをそれぞれO(logN)で答えるデータ構造"""
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def build(self, array):
"""arrayを初期値とするBinaryIndexTreeを構築する O(N)"""
for i in range(self.size):
self.bit[i + 1] = array[i]
for i in range(1, self.size):
if i + (i & -i) > self.size:
continue
self.bit[i + (i & -i)] += self.bit[i]
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
"""i番目の要素にvalを加える"""
i += 1
while i <= self.size:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
"""区間[l, r)の和を求める"""
return self._sum(r) - self._sum(l)
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query = [list(map(int, input().split())) + [i] for i in range(q)]
bit = BIT(n)
memo = {}
ans = [0] * q
query = sorted(query, key=itemgetter(1))
ind = 0
for l, r, i in query:
while ind < r:
if c[ind] in memo:
old_ind = memo[c[ind]]
else:
old_ind = -1
memo[c[ind]] = ind
bit.add(ind, 1)
if old_ind != -1:
bit.add(old_ind, -1)
ind += 1
ans[i] = bit.get_sum(l - 1, r)
print(("\n".join(map(str, ans)))) | p02599 |
import sys
input = sys.stdin.buffer.readline
from operator import itemgetter
class BIT:
"""一点加算、区間取得クエリをそれぞれO(logN)で答えるデータ構造"""
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def build(self, array):
"""arrayを初期値とするBinaryIndexTreeを構築する O(N)"""
for i in range(self.size):
self.bit[i + 1] = array[i]
for i in range(1, self.size):
if i + (i & -i) > self.size:
continue
self.bit[i + (i & -i)] += self.bit[i]
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
"""i番目の要素にvalを加える"""
i += 1
while i <= self.size:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
"""区間[l, r)の和を求める"""
return self._sum(r) - self._sum(l)
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query = [list(map(int, input().split())) + [i] for i in range(q)]
bit = BIT(n)
memo = {}
ans = [0] * q
query = sorted(query, key=itemgetter(1))
ind = 0
for l, r, i in query:
while ind < r:
if c[ind] in memo:
old_ind = memo[c[ind]]
else:
old_ind = -1
memo[c[ind]] = ind
bit.add(ind, 1)
if old_ind != -1:
bit.add(old_ind, -1)
ind += 1
ans[i] = bit.get_sum(l - 1, r)
print(("\n".join(map(str, ans)))) | import sys
input = sys.stdin.buffer.readline
from operator import itemgetter
class BIT:
"""一点加算、区間取得クエリをそれぞれO(logN)で答えるデータ構造"""
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def build(self, array):
"""arrayを初期値とするBinaryIndexTreeを構築する O(N)"""
for i in range(self.size):
self.bit[i + 1] = array[i]
for i in range(1, self.size):
if i + (i & -i) > self.size:
continue
self.bit[i + (i & -i)] += self.bit[i]
def _sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, val):
"""i番目の要素にvalを加える"""
i += 1
while i <= self.size:
self.bit[i] += val
i += i & -i
def get_sum(self, l, r):
"""区間[l, r)の和を求める"""
return self._sum(r) - self._sum(l)
n, q = list(map(int, input().split()))
c = list(map(int, input().split()))
query = []
OFFSET = 10 ** 6
for i in range(q):
l, r = list(map(int, input().split()))
query.append(i + OFFSET * l + OFFSET * OFFSET * r)
bit = BIT(n)
memo = {}
ans = [0] * q
query.sort()
ind = 0
for tmp in query:
i = tmp % OFFSET
l = (tmp // OFFSET) % OFFSET
r = tmp // (OFFSET * OFFSET)
while ind < r:
if c[ind] in memo:
old_ind = memo[c[ind]]
else:
old_ind = -1
memo[c[ind]] = ind
bit.add(ind, 1)
if old_ind != -1:
bit.add(old_ind, -1)
ind += 1
ans[i] = bit.get_sum(l - 1, r)
print(("\n".join(map(str, ans))))
| p02599 |
I = [int(_) for _ in open(0).read().split()]
N, Q = I[:2]
C = [0] + I[2:2 + N]
LR = I[2 + N:]
L, R = LR[::2], LR[1::2]
class BinaryIndexedTree():
def __init__(self, n):
"""
constructs binary indexed tree
Parameters
----------
n : int
maximum index value
"""
self.n = n
self.dat = [0] * (n + 1)
def sum(self, i):
"""
returns the sum of [1, i]
Parameters
----------
i : int
right end of the interval
"""
s = 0
while i:
s += self.dat[i]
i -= i & -i
return s
def add(self, i, x):
"""
adds x to i-th element
Parameters
----------
i : int
index
x : int
additional value
"""
while i <= self.n:
self.dat[i] += x
i += i & -i
BIT = BinaryIndexedTree(500010)
arr = [5 * 10**5 + 4] * (5 * 10**5 + 5)
RLI = sorted(r * (2 ** 40) + l * (2 ** 20) + i for r, l, i in zip(R, L, list(range(Q))))
ans = [None] * Q
j = 0
for rli in RLI:
r, li = divmod(rli, 2 ** 40)
l, i = divmod(li, 2 ** 20)
for j in range(j + 1, r + 1):
BIT.add(arr[C[j]], -1)
arr[C[j]] = j
BIT.add(j, 1)
ans[i] = BIT.sum(r) - BIT.sum(l - 1)
print(('\n'.join(map(str, ans))))
| I = [int(_) for _ in open(0).read().split()]
N, Q=I[:2]
C = I[2:2 + N]
LR = I[2 + N:]
2 ** 40
2 ** 20
Query = []
for i, lr in enumerate(zip(LR[::2], LR[1::2])):
l, r = lr
Query += [r * 2 ** 40 + l * 2 ** 20 + i]
for i, c in enumerate(C):
Query += [(i + 1) * 2 ** 40 + c]
Query.sort()
c_i = [-1] * (N + 1)
class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_right(self, p, v): # apply operator from the right side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(dat[p], v)
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_left(self, p, v): # apply operator from the left side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(v, dat[p])
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
vl = vr = ti
l += n
r += n
while l < r:
if l & 1:
vl = f(vl, dat[l])
l += 1
if r & 1:
r -= 1
vr = f(dat[r], vr)
l >>= 1
r >>= 1
return f(vl, vr)
ans = [0] * Q
st = SegmentTree([0] * (N + 5), lambda x,y:x+y, 0)
for q in Query:
x, yz = divmod(q, 2 ** 40)
y, z = divmod(yz, 2 ** 20)
if y==0:
if c_i[z] != -1:
st.operate_right(c_i[z], -1)
c_i[z] = x
st.operate_right(x, 1)
else:
ans[z] = st.query(y, x + 1)
print(*ans, sep='\n')
| p02599 |
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, Q, C, LR):
st = SegmentTree(f=lambda x, y: x | y, initial_values=[1 << (c - 1) for c in C])
for l, r in LR:
print((popcount(st.query(l - 1, r))))
def popcount(x):
x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555)
x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333)
x = x + (x >> 4) & 0x0f0f0f0f0f0f0f0f
x += x >> 8
x += x >> 16
x += x >> 32
return x & 0x7f
class SegmentTree:
def __init__(self, n=None, f=max, identity_factory=int, initial_values=None):
assert(n or initial_values)
size = n if n else len(initial_values)
d = [identity_factory() for _ in range(2 * size + 1)]
self.__n, self.__d, self.__f, self.__e = size, d, f, identity_factory
if initial_values:
for i, v in enumerate(initial_values): d[size + i] = v
for i in range(size - 1, 0, -1): d[i] = f(d[i << 1], d[i << 1 | 1])
def get_val(self, index):
return self.__d[index + self.__n]
def set_val(self, index, new_value):
i, d, f = index + self.__n, self.__d, self.__f
if d[i] == new_value: return
d[i] = new_value
while i:
i = i >> 1
d[i] = f(d[i << 1], d[i << 1 | 1])
def modify(self, index, value):
self.set_val(index, self.__f(self.__d[index + self.__n], value))
def query(self, from_inclusive, to_exclusive):
ans = self.__e()
if to_exclusive <= from_inclusive: return ans
l, r, d, f = from_inclusive + self.__n, to_exclusive + self.__n, self.__d, self.__f
while l < r:
if l & 1: ans, l = f(ans, d[l]), l + 1
if r & 1: ans, r = f(d[r - 1], ans), r - 1
l, r = l >> 1, r >> 1
return ans
if __name__ == '__main__':
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
*C, = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for _ in range(Q)]
main(N, Q, C, LR)
| # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, Q, C, LR):
ans = [0] * Q
LRi = [(l, r, i) for i, (l, r) in enumerate(LR)]
LRi.sort(key=lambda x: x[1])
bit = BinaryIndexedTree(N)
MR = [-1] * (N + 1)
p = 0
for l, r, i in LRi:
l, r = l - 1, r - 1
while p <= r:
c = C[p]
mr = MR[c]
if mr >= 0:
bit.add(mr, -1)
MR[c] = p
bit.add(p, 1)
p += 1
ans[i] = bit.query(r) - bit.query(l - 1)
for a in ans:
print(a)
class BinaryIndexedTree:
def __init__(self, n=None, f=lambda x, y: x + y, identity=0, initial_values=None):
assert(n or initial_values)
self.__f, self.__id, = f, identity
self.__n = len(initial_values) if initial_values else n
self.__d = [identity] * (self.__n + 1)
if initial_values:
for i, v in enumerate(initial_values): self.add(i, v)
def add(self, i, v):
n, f, d = self.__n, self.__f, self.__d
i += 1
while i <= n:
d[i] = f(d[i], v)
i += -i & i
def query(self, r):
res, f, d = self.__id, self.__f, self.__d
r += 1
while r:
res = f(res, d[r])
r -= -r & r
return res
if __name__ == '__main__':
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
*C, = list(map(int, input().split()))
LR = [tuple(map(int, input().split())) for _ in range(Q)]
main(N, Q, C, LR)
| p02599 |
NN = 19
XX = [0] * (2**(NN+1)-1)
def addvalue(j, x):
i = 2**NN + j - 1
while i >= 0:
XX[i] += x
i = (i-1) // 2
def rangesum(a, b):
l = a + (1<<NN)
r = b + (1<<NN)
s = 0
while l < r:
if l%2:
s += XX[l-1]
l += 1
if r%2:
r -= 1
s += XX[r-1]
l >>= 1
r >>= 1
return s
N, Q = map(int, input().split())
C = [int(a) - 1 for a in input().split()]
X = [[] for _ in range(N)]
for i in range(Q):
l, r = map(int, input().split())
X[r-1].append((l - 1, i))
last = [-1] * N
ANS = [-1] * Q
addvalue(1, N)
for r in range(N):
c = C[r]
addvalue(last[c] + 2, -1)
addvalue(r + 2, 1)
last[c] = r
for l, i in X[r]:
ANS[i] = rangesum(l + 2, 1 << NN)
print(*ANS, sep = "\n")
| ##### https://atcoder.jp/contests/abc174/submissions/15644075 を1次元化
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.buffer.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 << 40) + (r << 20) + i
queries.sort(reverse = 1)
m = (1 << 20) - 1
ans = [0] * q
for l in range(n):
while queries and queries[-1] >> 40 == l:
lri = queries.pop()
l = lri >> 40
r = (lri >> 20) & m
i = lri & m
ans[i] = tree.sum(l, r)
if next[l] != -1:
tree.add(next[l], 1)
print(*ans, sep = '\n')
resolve()
| p02599 |
I=lambda:list(map(int,input().split()))
N=0xfffff
n,q=I()
c=list(I())
Q=[]
for i in range(q):l,r=I();Q.append(l<<40|r<<20|i)
Q.sort()
A=[[]for i in range(N)]
for i,x in enumerate(c):A[x].append(i)
B=[0]*N
def P(i,x):
i+=1
while i<=n:B[i]+=x;i+=i&-i
def G(i):
s=0
while i:s+=B[i];i-=i&-i
return s
for i in A:
if i:P(i[0],1);i.reverse()
t=0
o=[0]*q
for x in Q:
l=x>>40
r=x>>20&N
i=x&N
while t+1<l:
b=A[c[t]]
P(b[-1],-1)
b.pop()
if b:P(b[-1],1)
t+=1
o[i]=G(r)-G(l-1)
for i in o:print(i) | I=lambda:list(map(int,input().split()))
N=0xfffff
n,q=I()
c=list(I())
Q=[]
for i in range(q):l,r=I();Q.append(l<<40|r<<20|i)
Q.sort()
A=[[]for i in range(N)]
for i in range(n):A[c[i]].append(i)
B=[0]*N
def P(i,x):
i+=1
while i<=n:B[i]+=x;i+=i&-i
def G(i):
s=0
while i:s+=B[i];i-=i&-i
return s
for i in A:
if i:P(i[0],1);i.reverse()
t=0
o=[0]*q
for x in Q:
l=x>>40
r=x>>20&N
i=x&N
while t+1<l:
b=A[c[t]]
P(b[-1],-1)
b.pop()
if b:P(b[-1],1)
t+=1
o[i]=G(r)-G(l-1)
for i in o:print(i) | p02599 |
I=lambda:list(map(int,input().split()))
N=0xfffff
n,q=I()
c=list(I())
Q=[]
R=range
for i in R(q):l,r=I();Q.append(l<<40|r<<20|i)
Q.sort()
A=[[]for i in R(N)]
for i in R(n):A[c[i]].append(i)
B=[0]*N
def P(i,x):
i+=1
while i<=n:B[i]+=x;i+=i&-i
def G(i):
s=0
while i:s+=B[i];i-=i&-i
return s
for i in A:
if i:P(i[0],1);i.reverse()
t=0
o=[0]*q
for x in Q:
l=x>>40
r=x>>20&N
i=x&N
while t+1<l:
b=A[c[t]]
P(b[-1],-1)
b.pop()
if b:P(b[-1],1)
t+=1
o[i]=G(r)-G(l-1)
for i in o:print(i) | I=lambda:list(map(int,input().split()))
N=0xfffff
n,q=I()
c=list(I())
Q=[]
R=range
for i in R(q):l,r=I();Q.append(l<<40|r<<20|i)
Q.sort()
A=[[]for i in R(N)]
for i in R(n):A[c[i]].append(i)
B=[0]*N
def P(i,x):
i+=1
while i<=n:B[i]+=x;i+=i&-i
for i in A:
if i:P(i[0],1);i.reverse()
t=0
o=[0]*q
for x in Q:
l=(x>>40)-1
r=x>>20&N
i=x&N
while t<l:
b=A[c[t]]
P(b[-1],-1)
b.pop()
if b:P(b[-1],1)
t+=1
while r:o[i]+=B[r];r-=r&-r
while l:o[i]-=B[l];l-=l&-l
for i in o:print(i) | p02599 |
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.buffer.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
def lower_bound(self, w):
if w <= 0:
return 0
x = 0
k = 1 << (self.size.bit_length() - 1)
while k:
if x + k <= self.size and self.tree[x + k] < w:
w -= self.tree[x + k]
x += k
k >>= 1
return x + 1
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
query = []
for q in range(Q):
query.append(list(map(int, input().split())))
query[-1].append(q)
query.sort(key=lambda x: x[1])
last = [0] * (N+1)
for i, c in enumerate(C):
if i > query[0][1]-1:
break
last[c] = i+1
bit = Bit(N)
for i in range(1, N+1):
if last[i]:
bit.add(last[i], 1)
r_prev = query[0][1]
ans = [0] * Q
for l, r, q in query:
if r > r_prev:
for i in range(r_prev+1, r+1):
j = last[C[i-1]]
if j:
bit.add(j, -1)
last[C[i-1]] = i
bit.add(i, 1)
ans[q] = bit.sum(r) - bit.sum(l-1)
for a in ans:
print(a)
if __name__ == '__main__':
main()
| mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.buffer.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
def lower_bound(self, w):
if w <= 0:
return 0
x = 0
k = 1 << (self.size.bit_length() - 1)
while k:
if x + k <= self.size and self.tree[x + k] < w:
w -= self.tree[x + k]
x += k
k >>= 1
return x + 1
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
query = []
for q in range(Q):
query.append(list(map(int, input().split())))
query[-1].append(q)
query.sort(key=lambda x: x[1])
last = [0] * (N+1)
for i, c in enumerate(C):
if i > query[0][1]-1:
break
last[c] = i+1
bit = Bit(N)
for i in range(1, N+1):
if last[i]:
bit.add(last[i], 1)
r_prev = query[0][1]
ans = [0] * Q
for l, r, q in query:
if r > r_prev:
for i in range(r_prev+1, r+1):
j = last[C[i-1]]
if j:
bit.add(j, -1)
last[C[i-1]] = i
bit.add(i, 1)
r_prev = r
ans[q] = bit.sum(r) - bit.sum(l-1)
for a in ans:
print(a)
if __name__ == '__main__':
main()
| p02599 |
N, Q = list(map(int, input().split()))
lists = [list(map(int, input().split())) for i in range(Q+1)]
master = lists.pop(0)
X = [master[l[0]-1:l[1]] for l in lists]
for x in X:
print((len(set(x))))
| N, Q = list(map(int, input().split()))
lists = [list(map(int, input().split())) for i in range(Q+1)]
master = lists.pop(0)
X = [len(set(master[l[0]-1:l[1]])) for l in lists]
for x in X:
print(x)
| p02599 |
class Bit:
def __init__(self,n):
self.bl = n.bit_length()
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
import sys
input = sys.stdin.readline
from collections import defaultdict
n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
lr = [list(map(int,input().split())) for i in range(q)]
ans = [0]*q
for i in range(q):
lr[i].append(i)
lr.sort(key = lambda x:x[1])
bit = Bit(n+2)
dc = defaultdict(int)
cnt = 0
for L,R,p in lr:
L -= 1
for i in range(cnt,R):
if dc[a[i]]:
l = dc[a[i]]-1
r = i
bit.add(l+2,1)
bit.add(r+2,-1)
else:
bit.add(1,1)
bit.add(i+2,-1)
dc[a[i]] = i+1
ans[p] = bit.sum(L+1)
cnt = R
for i in ans:
print(i) | class Bit:
def __init__(self,n):
self.bl = n.bit_length()
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
import sys
input = sys.stdin.readline
from collections import defaultdict
n,q = map(int,input().split())
a = list(map(int,input().split()))
lr = [tuple(map(int,input().split()))+(i,) for i in range(q)]
ans = [0]*q
lr.sort(key = lambda x:x[1])
bit = Bit(n+2)
dc = defaultdict(int)
cnt = 0
for L,R,p in lr:
L -= 1
for i in range(cnt,R):
if dc[a[i]]:
l = dc[a[i]]-1
r = i
bit.add(l+2,1)
bit.add(r+2,-1)
else:
bit.add(1,1)
bit.add(i+2,-1)
dc[a[i]] = i+1
ans[p] = bit.sum(L+1)
cnt = R
print(*ans,sep="\n")
| p02599 |
from collections import defaultdict
n, q = (int(i) for i in input().split())
nums = [0] # not a color
nums = [int(i) for i in input().split()]
nums_info = []
colors = defaultdict(lambda: 0)
for num in nums:
colors[num] += 1
nums_info.append(dict(colors))
#print(nums_info)
for _ in range(q):
s, e = (int(i) for i in input().split())
s -= 2
e -= 1
if s < 0:
print((len(list(nums_info[e].keys()))))
continue
if e - s == len(nums_info[e]) - len(nums_info[s]):
print((e - s))
continue
count = 0
for k, v in list(nums_info[e].items()):
if k in nums_info[s] and nums_info[s][k] == v:
continue
count += 1
print(count)
| n, q = (int(i) for i in input().split())
nums = [int(i) for i in input().split()]
#print(nums_info)
for _ in range(q):
s, e = (int(i) for i in input().split())
s -= 1
ans = set()
for i in range(s, e):
ans.add(nums[i])
print((len(ans)))
| p02599 |
from sys import stdin
#import numpy as np
readline = stdin.readline
N, Q = map(int, readline().split())
C = list(map(int, readline().split()))
S = [list(map(int, readline().split())) for _ in range(Q)]
def main(N, Q, C, S):
# Binary Indexed Tree
# https://juppy.hatenablog.com/entry/2018/11/17/%E8%9F%BB%E6%9C%AC_python_Binary_Indexed_Tree_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0
b = [0 for _ in range(N+1)]
def BIT_query(idx): #idxまでの和(1からスタート)
res_sum = 0
while idx > 0:
res_sum += b[idx]
idx -= idx&(-idx) #一番下の位を減らす（例：13=1011 → 1010 → 1000）
return res_sum
def BIT_update(idx,x): #idxをx増やした時
while idx <= N:
b[idx] += x
idx += idx&(-idx) #一番下の位を繰り上げる（例：13=1011 → 1100 → 10000 ※N=16のとき）
return
loc = [0 for _ in range(N)] #各種類の玉のうちの最右端の所在地
S = [[S[i][1], S[i][0], i] for i in range(Q)] #クエリ
S.sort() #区間の右端でソート
#S = np.array(S, dtype = np.int64)
#print(S)
ans = [0 for _ in range(Q)]
k = 0
for j in range(N):
if loc[C[j]-1] > 0: #玉の更新
BIT_update(loc[C[j]-1], -1)
loc[C[j]-1] = j+1
BIT_update(j+1, 1)
if S[k][0] == j+1:
t = BIT_query(j+1)
while k < len(S) and S[k][0] == j+1: #クエリへの返答
ans[S[k][2]] = t - BIT_query(S[k][1]-1)
k += 1
if k == len(S):
break
return ans
ans = main(N, Q, C, S)
print(*ans, sep='\n')
| from sys import stdin
#import numpy as np
readline = stdin.readline
N, Q = map(int, readline().split())
C = list(map(int, readline().split()))
S = [list(map(int, readline().split())) for _ in range(Q)]
#print(S)
def main(N, Q, C, S):
# Binary Indexed Tree
# https://juppy.hatenablog.com/entry/2018/11/17/%E8%9F%BB%E6%9C%AC_python_Binary_Indexed_Tree_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0
b = [0 for _ in range(N+1)]
def BIT_query(idx): #idxまでの和(1からスタート)
res_sum = 0
while idx > 0:
res_sum += b[idx]
idx -= idx&(-idx) #一番下の位を減らす（例：13=1011 → 1010 → 1000）
return res_sum
def BIT_update(idx,x): #idxをx増やした時
while idx <= N:
b[idx] += x
idx += idx&(-idx) #一番下の位を繰り上げる（例：13=1011 → 1100 → 10000 ※N=16のとき）
return
loc = [0 for _ in range(N)] #各種類の玉のうちの最右端の所在地
S = [(S[i], i) for i in range(Q)] #クエリ
S.sort(key = lambda s: s[0][1]) #区間の右端でソート
#S = np.array(S, dtype = np.int64)
#print(S)
ans = [0 for _ in range(Q)]
k = 0
for j in range(N):
if loc[C[j]-1] > 0: #玉の更新
BIT_update(loc[C[j]-1], -1)
loc[C[j]-1] = j+1
BIT_update(j+1, 1)
if S[k][0][1] == j+1:
t = BIT_query(j+1)
while k < len(S) and S[k][0][1] == j+1: #クエリへの返答
ans[S[k][1]] = t - BIT_query(S[k][0][0]-1)
k += 1
if k == len(S):
break
return ans
ans = main(N, Q, C, S)
print(*ans, sep='\n')
| p02599 |
BIT = [0] * ((1 << 19) + 1)
def add(i, x):
while i <= (1 << 19):
BIT[i] += x
i += i & (-i)
def query(i):
res = 0
while i > 0:
res += BIT[i]
i -= i & (-i)
return res
n, q = map(int, input().split())
c = list(map(int, input().split()))
Q = [[] for i in range(n)]
for i in range(q):
l, r = map(int, input().split())
Q[r - 1].append([l - 1, i])
l = [-1] * n
a = [-1] * q
add(1, n)
for i in range(n):
add(l[c[i] - 1] + 2, -1)
add(i + 2, 1)
l[c[i] - 1] = i
for j in Q[i]:
a[j[1]] = query(1 << 19) - query(j[0] + 1)
print(*a, sep="\n")
| BIT = [0] * ((1 << 19) + 1)
def add(i, x):
while i <= (1 << 19):
BIT[i] += x
i += i & -i
def query(i):
res = 0
while i > 0:
res += BIT[i]
i -= i & -i
return res
n, q = map(int, input().split())
c = list(map(int, input().split()))
Q = [[] for i in range(n)]
for i in range(q):
l, r = map(int, input().split())
Q[r - 1].append([l - 1, i])
l = [-1] * n
a = [-1] * q
add(1, n)
for i in range(n):
add(l[c[i] - 1] + 2, -1)
add(i + 2, 1)
l[c[i] - 1] = i
for j in Q[i]:
a[j[1]] = query(1 << 19) - query(j[0] + 1)
print(*a, sep="\n")
| p02599 |
import sys
read=sys.stdin.buffer.readline
class BIT:
def __init__(self,N):
self.N=N
self.bit=[0]*N
def add(self,a,w):
x=a
while(x<self.N):
self.bit[x]+=w
x|=x+1
def get(self,a):
ret,x=0,a-1
while(x>=0):
ret+=self.bit[x]
x=(x&(x+1))-1
return ret
def cum(self,l,r):
return self.get(r)-self.get(l)
def main():
def update(x,i):
if good[x]==-1:
good[x]=i
bit.add(i,1)
else:
bit.add(good[x],-1)
good[x]=i
bit.add(good[x],1)
N,Q=map(int,read().split())
c=list(map(int,read().split()))
li=[list(map(lambda x:int(x)-1,read().split()))+[i] for i in range(Q)]
Query=[(li[i][0],li[i][1],i) for i in range(Q)]
Query.sort(key=lambda x:x[1])
ans=[-1]*Q
good=[-1]*(N+1)
bit=BIT(N)
i=0
for L,R,w in Query:
while(i<=R and i<N):
update(c[i],i)
i+=1
ans[w]=bit.cum(L,R+1)
print(*ans,sep='\n')
if __name__=='__main__':
main()
| import sys
read=sys.stdin.buffer.readline
class BIT:
def __init__(self,N):
self.N=N
self.bit=[0]*N
def add(self,a,w):
x=a
while(x<self.N):
self.bit[x]+=w
x|=x+1
def get(self,a):
ret,x=0,a-1
while(x>=0):
ret+=self.bit[x]
x=(x&(x+1))-1
return ret
def cum(self,l,r):
return self.get(r)-self.get(l)
def main():
def update(x,i):
if good[x]==-1:
good[x]=i
bit.add(i,1)
else:
bit.add(good[x],-1)
good[x]=i
bit.add(good[x],1)
return
N,Q=map(int,read().split())
c=tuple(map(int,read().split()))
Query=[]
for i in range(Q):
l,r=map(lambda x:int(x)-1,read().split())
Query.append((l,r,i))
Query.sort(key=lambda x:x[1])
ans=[-1]*Q
good=[-1]*(N+1)
bit=BIT(N)
i=0
for L,R,w in Query:
while(i<=R):
update(c[i],i)
i+=1
ans[w]=bit.cum(L,R+1)
print(*ans,sep='\n')
return
if __name__=='__main__':
main()
| p02599 |
import sys
read=sys.stdin.buffer.readline
class BIT:
def __init__(self,N):
self.N=N
self.bit=[0]*N
def add(self,a,w):
x=a
while(x<self.N):
self.bit[x]+=w
x|=x+1
def get(self,a):
ret,x=0,a-1
while(x>=0):
ret+=self.bit[x]
x=(x&(x+1))-1
return ret
def cum(self,l,r):
return self.get(r)-self.get(l)
def update(x,i):
if good[x]==-1:
good[x]=i
bit.add(i,1)
else:
bit.add(good[x],-1)
good[x]=i
bit.add(good[x],1)
return
N,Q=map(int,read().split())
c=tuple(map(int,read().split()))
Query=[]
for i in range(Q):
l,r=map(lambda x:int(x)-1,read().split())
Query.append((l,r,i))
Query.sort(key=lambda x:x[1])
ans=[-1]*Q
good=[-1]*(N+1)
bit=BIT(N)
i=0
for L,R,w in Query:
while(i<=R):
update(c[i],i)
i+=1
ans[w]=bit.cum(L,R+1)
print(*ans,sep='\n')
| import sys
read=sys.stdin.buffer.readline
class BIT:
def __init__(self,N):
self.N=N
self.bit=[0]*N
def add(self,a,w):
x=a
while(x<self.N):
self.bit[x]+=w
x|=x+1
def get(self,a):
ret,x=0,a-1
while(x>=0):
ret+=self.bit[x]
x=(x&(x+1))-1
return ret
def cum(self,l,r):
return self.get(r)-self.get(l)
def update(x,i):
if good[x]==-1:
good[x]=i
bit.add(i,1)
else:
bit.add(good[x],-1)
good[x]=i
bit.add(good[x],1)
return
N,Q=map(int,read().split())
c=tuple(map(int,read().split()))
Query=[]
for i in range(Q):
l,r=map(lambda x:int(x)-1,read().split())
Query.append(r*10**12+l*10**6+i)
Query.sort()
ans=[-1]*Q
good=[-1]*(N+1)
bit=BIT(N)
i=0
for w in Query:
R=w//10**12
w%=10**12
L=w//10**6
w%=10**6
while(i<=R):
update(c[i],i)
i+=1
ans[w]=bit.cum(L,R+1)
print(*ans,sep='\n')
| p02599 |
def main():
import sys
input = sys.stdin.readline
class BIT:
def __init__(self,n):
self.tree = [0]*(n+1)
self.size = n
def add(self,i,x):
while i <= self.size:
self.tree[i] += x
i += i&-i
def sum(self,i):
s = 0
while i > 0:
s += self.tree[i]
i -= i&-i
return s
N,Q = list(map(int,input().split()))
bit = BIT(N)
C = list(map(int,input().split()))
query = []
for i in range(Q):
l,r = list(map(int,input().split()))
query.append([l,r,i])
query.sort(key=lambda x: x[1])
ans = []
#良い玉のindexを1-indexで管理する
colorMemo = [0]*(N+1)
cur = 1
for q in query:
l,r,j = q
#良い玉の情報を更新する
for i in range(cur,r+1):
c = C[i-1]
if colorMemo[c]:
bit.add(colorMemo[c],-1)
bit.add(i,1)
colorMemo[c] = i
cur = r + 1
ans.append([j,bit.sum(r)-bit.sum(l-1)])
ans.sort()
for a in ans:
print((a[1]))
main() | def main():
import sys
input = sys.stdin.readline
class BIT:
def __init__(self,n):
self.tree = [0]*(n+1)
self.size = n
def add(self,i,x):
while i <= self.size:
self.tree[i] += x
i += i&-i
def sum(self,i):
s = 0
while i > 0:
s += self.tree[i]
i -= i&-i
return s
N,Q = map(int,input().split())
bit = BIT(N)
C = list(map(int,input().split()))
query = []
for i in range(Q):
l,r = map(int,input().split())
query.append([l,r,i])
query.sort(key=lambda x: x[1])
ans = [0]*Q
#良い玉のindexを1-indexで管理する
colorMemo = [0]*(N+1)
cur = 1
for q in query:
l,r,j = q
#良い玉の情報を更新する
for i in range(cur,r+1):
c = C[i-1]
if colorMemo[c]:
bit.add(colorMemo[c],-1)
bit.add(i,1)
colorMemo[c] = i
cur = r + 1
ans[j]=bit.sum(r)-bit.sum(l-1)
print(*ans, sep="\n")
main()
| p02599 |
def main():
import sys
input = sys.stdin.readline
class BIT:
def __init__(self,n):
self.tree = [0] * (n+1)
self.size = n
def add(self,i,x):
while i <= self.size:
self.tree[i] += x
i += i&-i
def get(self,i):
s = 0
while i > 0:
s += self.tree[i]
i -= i&-i
return s
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 = BIT(N)
stone = [0]*(N+1)
cur = 1
ans = [0]*(Q)
for l,r,i in LR:
for j in range(cur,r+1):
c = C[j-1]
if stone[c]:
bit.add(stone[c],-1)
stone[c] = j
bit.add(stone[c],1)
ans[i] = bit.get(r)-bit.get(l-1)
for a in ans:
print(a)
main() | def main():
import sys
input = sys.stdin.readline
class BIT:
def __init__(self,n):
self.tree = [0]*(n+1)
self.size = n
def add(self,i,x):
while i <= self.size:
self.tree[i] += x
i += i&-i
def sum(self,i):
s = 0
while i > 0:
s += self.tree[i]
i -= i&-i
return s
N,Q = list(map(int,input().split()))
bit = BIT(N)
C = list(map(int,input().split()))
query = []
for i in range(Q):
l,r = list(map(int,input().split()))
query.append([l,r,i])
query.sort(key=lambda x: x[1])
ans = [0]*Q
#良い玉のindexを1-indexで管理する
colorMemo = [0]*(N+1)
cur = 1
for q in query:
l,r,j = q
#良い玉の情報を更新する
for i in range(cur,r+1):
c = C[i-1]
if colorMemo[c]:
bit.add(colorMemo[c],-1)
bit.add(i,1)
colorMemo[c] = i
cur = r + 1
ans[j]=bit.sum(r)-bit.sum(l-1)
for a in ans:
print(a)
main()
| p02599 |
# Date [ 2020-09-06 11:56:02 ]
# Problem [ f.py ]
# Author Koki_tkg
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
class BinaryIndexedTree:
def __init__(self, n):
'''1-index'''
self.size = n + 1
self.data = [0] * self.size
self.element = [0] * self.size
self.depth = 1 << n.bit_length() - 1
def build(self, array):
for i, x in enumerate(array):
self.add(i, x)
def add(self, i, v):
self.element[i] += v; i += 1 # 1-index
while i < self.size:
self.data[i] += v
i += i & -i
def _sum(self, i):
ret = 0
while i > 0:
ret += self.data[i]
i -= i & -i
return ret
def get_sum(self, l, r=None):
'''get sum [l, r)'''
if r == None: return self.element[l]
return self._sum(r) - self._sum(l-1)
def lower_bound(self, v):
if v <= 0: return 0
k = self.depth; i = 0
while k > 0:
if i+k < self.size and self.data[i+k] < v:
v -= self.data[i+k]
i += k
k >>= 1
return i+1
def Main():
n, q = read_ints()
c = read_int_list()
query = [(read_ints()) for _ in range(q)]
que = defaultdict(list)
for i, (l, r) in enumerate(query):
que[r].append([l, i])
ans = [0] * q
last = [-1] * (n + 1)
bit = BinaryIndexedTree(n)
for i, x in enumerate(c):
if last[x] > 0:
bit.add(last[x]-1, -1)
last[x] = i + 1
bit.add(last[x]-1, 1)
if len(que[i + 1]) > 0:
for l, j in que[i + 1]:
ans[j] = bit.get_sum(l, i+1)
print(*ans, sep='\n')
if __name__ == '__main__':
Main()
| import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
class BinaryIndexedTree:
def __init__(self, n):
'''1-index'''
self.size = n + 1
self.data = [0] * self.size
self.element = [0] * self.size
self.depth = 1 << n.bit_length() - 1
def build(self, array):
for i, x in enumerate(array):
self.add(i, x)
def add(self, i, v):
self.element[i] += v; i += 1 # 1-index
while i < self.size:
self.data[i] += v
i += i & -i
def _sum(self, i):
ret = 0
while i > 0:
ret += self.data[i]
i -= i & -i
return ret
def get_sum(self, l, r=None):
'''get sum [l, r)'''
if r == None: return self.element[l]
return self._sum(r) - self._sum(l-1)
def lower_bound(self, v):
if v <= 0: return 0
k = self.depth; i = 0
while k > 0:
if i+k < self.size and self.data[i+k] < v:
v -= self.data[i+k]
i += k
k >>= 1
return i+1
def Main():
n, q = read_ints()
c = read_int_list()
query = [(read_ints()) for _ in range(q)]
que = defaultdict(list)
for i, (l, r) in enumerate(query):
que[r].append([l, i])
ans = [0] * q
last = [-1] * (n + 1)
bit = BinaryIndexedTree(n)
for i, x in enumerate(c):
if last[x] > 0:
bit.add(last[x]-1, -1)
last[x] = i + 1
bit.add(last[x]-1, 1)
if len(que[i + 1]) > 0:
for l, j in que[i + 1]:
ans[j] = bit.get_sum(l, i+1)
print(*ans, sep='\n')
if __name__ == '__main__':
Main()
| p02599 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
# Reference: https://www.geeksforgeeks.org/queries-number-distinct-elements-subarray/
# Python3 code to find number of
# distinct numbers in a subarray
MAX = 1000001
# 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]))
# This code is contributed by
# sanjeev2552
def main():
N, Q = list(map(int, readline().split()))
C = list(map(int, readline().split()))
(*LR,) = list(map(int, read().split()))
queries = [0] * Q
for i, (l, r) in enumerate(zip(*[iter(LR)] * 2)):
queries[i] = Query(l - 1, r - 1, i)
queries.sort(key=lambda x: x.r)
answeringQueries(C, N, queries, Q)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
def add(self, i, x=1):
i += 1
while i <= self.n:
self.data[i] += x
i += i & -i
def get_sum(self, i):
i += 1
x = 0
while i > 0:
x += self.data[i]
i -= i & -i
return x
# Return sum for [l, r)
def get_sum_range(self, l, r):
return self.get_sum(r - 1) - self.get_sum(l - 1)
def main():
N, Q = map(int, readline().split())
C = list(map(int, readline().split()))
LR = map(int, read().split())
prev = [-1] * (N + 1)
ps = [[] for _ in range(N)]
for i, c in enumerate(C):
if prev[c] != -1:
ps[prev[c]].append(i)
prev[c] = i
qs = [[] for _ in range(N + 1)]
for i, (l, r) in enumerate(zip(*[iter(LR)] * 2)):
l -= 1
r -= 1
qs[l].append((r, i))
ans = [0] * Q
bit = BIT(N)
for l in range(N - 1, -1, -1):
for r in ps[l]:
bit.add(r)
for r, i in qs[l]:
ans[i] = (r - l + 1) - bit.get_sum(r)
print(*ans, sep='\n')
return
if __name__ == '__main__':
main()
| p02599 |
import sys
input = sys.stdin.buffer.readline
n, q = list(map(int, input().split()))
C = list(map(int, input().split()))
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
num = 2 ** ((n - 1).bit_length())
SEG = [0] * (2 * num)
def func(a, b):
return a | b
for idx, val in enumerate(C):
idx += num
SEG[idx] = 1 << (val - 1)
while idx > 0:
idx //= 2
SEG[idx] = func(SEG[2 * idx], SEG[2 * idx + 1])
def query(left, right):
resleft = 0
resright = 0
left += num
right += num
while right - left > 0:
if left % 2 == 1:
resleft = func(resleft, SEG[left])
left += 1
if right % 2 == 1:
right -= 1
resright = func(resright, SEG[right])
left //= 2
right //= 2
return func(resleft, resright)
for _ in range(q):
l, r = list(map(int, input().split()))
temp = query(l - 1, r)
print((popcnt(temp)))
| import sys
input = sys.stdin.buffer.readline
n, q = map(int, input().split())
C = list(map(int, input().split()))
LR = []
for i in range(q):
l, r = map(int, input().split())
LR.append((l, r, i))
LR.sort(key=lambda x: x[1])
BIT = [0] * (n + 1)
def update(idx, val):
while idx <= n:
BIT[idx] += val
idx += idx & (-idx)
def query(idx):
res = 0
while idx > 0:
res += BIT[idx]
idx -= idx & (-idx)
return res
pos = [-1] * (n + 1)
def func(idx):
temp = C[idx]
if pos[temp] == -1:
pos[temp] = idx + 1
update(idx + 1, 1)
else:
pre = pos[temp]
pos[temp] = idx + 1
update(pre, -1)
update(idx + 1, 1)
ans = [0] * (q)
idx = 0
for i in range(q):
l, r, ans_num = LR[i]
# l,rは0-indexに戻す
l -= 1
r -= 1
while idx < r + 1: # rになるまで増やす
if idx < n: # n超えないように注意
func(idx)
idx += 1
else:
break
res = 0
res += query(r + 1)
if l > 0:
res -= query(l)
ans[ans_num] = res
print(*ans, sep="\n")
| p02599 |
from operator import or_
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
class SparseTable:
def __init__(self, N, arr, op):
self.N = N
self.depth = N.bit_length()
self.op = op
self.arr = tuple(arr)
self._build()
def __call__(self, s, t):
"""
[s, t)区間（0-indexed）での値を返す
"""
i = (t - s).bit_length() - 1
L = self.table[i][s]
R = self.table[i][t - (1 << i)]
return self.op(L, R)
def _build(self):
self.table = []
self.table.append(self.arr)
N = self.N
for i in range(self.depth - 1):
shift = 1 << i
N -= shift
t = tuple(self.op(self.table[-1][j], self.table[-1][j+shift])
for j in range(N))
self.table.append(t)
N, Q = list(map(int, input().split()))
C = [1 << (i-1) for i in map(int, input().split())] + [0]
sp = SparseTable(N+1, C, or_)
for _ in range(Q):
s, t = list(map(int, input().split()))
b = bin(sp(s-1, t)).count("1")
print(b) | class SegmentTree:
def __init__(self, N, arr=None, op=None):
"""
INPUT
N: 配列のサイズ
segment tree: 1-indexedで構築
original array: 0-indexed
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15
---------------------
0 1 2 3 4 5 6 7
"""
self.N = N
self.op = op
self.tree = [set()] * (2 * N + 1)
if arr is not None:
self._build(arr)
def _build(self, arr):
op = self.op
N = self.N
for i, a in enumerate(arr, N):
self.tree[i] = set([a])
for i in reversed(list(range(1, N))):
self.tree[i] = op(self.tree[i << 1], self.tree[i << 1 | 1])
def update(self, i, x):
"""
arr[i]の値をxに変更する
i: 0-indexed
"""
i += self.N
op = self.op
self.tree[i] = x
while i > 1:
i >>= 1
self.tree[i] = op(self.tree[i << 1], self.tree[i << 1 | 1])
def query(self, L, R):
"""
L,R: 0-indexed
半開区間[L,R)の累積演算した値を返す
"""
op = self.op
res = set()
L += self.N
R += self.N
while L < R:
if L & 1:
res = op(res, self.tree[L])
L += 1
if R & 1:
R -= 1
res = op(res, self.tree[R])
L >>= 1
R >>= 1
return len(res)
def union(a, b):
return a | b
N, Q = list(map(int, input().split()))
C = list(map(int, input().split()))
seg = SegmentTree(N, C, union)
for _ in range(Q):
s, t = list(map(int, input().split()))
print((seg.query(s-1, t))) | p02599 |
import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.size = n
self.array = [0] * (n + 1)
self.e = [0] * n
def sum(self, i):
s = 0
tmp = i
while tmp > 0:
s += self.array[tmp]
tmp -= tmp & -tmp
return s
def add(self, i, x):
self.e[i] += x
tmp = i + 1
while tmp <= self.size:
self.array[tmp] += x
tmp += tmp & -tmp
def main():
n, q = map(int, input().split())
*C, = map(lambda x: int(x) - 1, input().split())
P = [0] * n
N = [0] * n
for i in range(n)[::-1]:
if P[C[i]]:
N[i] = P[C[i]]
P[C[i]] = i
F = [0] * n
B = BIT(n)
for i in range(n):
if F[C[i]] == 0:
B.add(i, 1)
F[C[i]] = 1
XY = sorted([(tuple(map(int, input().split())), j) for j in range(q)])
a = 0
lst = [0] * q
for (x, y), j in XY:
for i in range(a, x - 1):
B.add(N[i], 1)
a = x - 1
lst[j] = B.sum(y) - B.sum(x - 1)
print(*lst, sep="\n")
main()
| import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.array = [0] * (n + 1)
self.size = n
def sum(self, i):
s = 0
tmp = i
while tmp > 0:
s += self.array[tmp]
tmp -= tmp & -tmp
return s
def add(self, i, x):
tmp = i + 1
while tmp <= self.size:
self.array[tmp] += x
tmp += tmp & -tmp
def main():
n, q = map(int, input().split())
*C, = map(lambda x: int(x) - 1, input().split())
P = [0] * n
N = [None] * n
for i in range(n)[::-1]:
if P[C[i]]:
N[i] = P[C[i]]
P[C[i]] = i
F = [0] * n
B = BIT(n)
for i in range(n):
if F[C[i]] == 0:
B.add(i, 1)
F[C[i]] = 1
XY = [tuple(map(int, input().split())) for j in range(q)]
ids = list(range(q))
ids.sort(key=lambda j: XY[j][0])
a = 0
lst = [0] * q
for j in ids:
x, y = XY[j]
for i in range(a, x - 1):
if N[i]:
B.add(N[i], 1)
a = x - 1
lst[j] = B.sum(y) - B.sum(x - 1)
print(*lst, sep="\n")
main()
| p02599 |
class BIT:
def __init__(self, n):
self.array = [0] * (n + 1)
self.size = n
def sum(self, i):
s = 0
tmp = i
while tmp > 0:
s += self.array[tmp]
tmp -= tmp & -tmp
return s
def add(self, i, x):
tmp = i + 1
while tmp <= self.size:
self.array[tmp] += x
tmp += tmp & -tmp
def main():
n, q = map(int, input().split())
*C, = map(lambda x: int(x) - 1, input().split())
P = [0] * n
N = [None] * n
for i in range(n)[::-1]:
if P[C[i]]:
N[i] = P[C[i]]
P[C[i]] = i
F = [0] * n
B = BIT(n)
for i in range(n):
if F[C[i]] == 0:
B.add(i, 1)
F[C[i]] = 1
XY = [tuple(map(int, input().split())) for j in range(q)]
ids = list(range(q))
ids.sort(key=lambda j: XY[j][0])
a = 0
lst = [0] * q
for j in ids:
x, y = XY[j]
for i in range(a, x - 1):
if N[i]:
B.add(N[i], 1)
a = x - 1
lst[j] = B.sum(y) - B.sum(x - 1)
print(*lst, sep="\n")
main()
| import sys
input = sys.stdin.readline
class BIT:
def __init__(self, n):
self.array = [0] * (n + 1)
self.size = n
def sum(self, i):
s = 0
tmp = i
while tmp > 0:
s += self.array[tmp]
tmp -= tmp & -tmp
return s
def add(self, i, x):
tmp = i + 1
while tmp <= self.size:
self.array[tmp] += x
tmp += tmp & -tmp
n, q = map(int, input().split())
*C, = map(lambda x: int(x) - 1, input().split())
P = [0] * n
N = [None] * n
for i in range(n)[::-1]:
if P[C[i]]:
N[i] = P[C[i]]
P[C[i]] = i
F = [0] * n
B = BIT(n)
for i in range(n):
if F[C[i]] == 0:
B.add(i, 1)
F[C[i]] = 1
XY = [tuple(map(int, input().split())) for j in range(q)]
ids = list(range(q))
ids.sort(key=lambda j: XY[j][0])
a = 0
lst = [0] * q
for j in ids:
x, y = XY[j]
for i in range(a, x - 1):
if N[i]:
B.add(N[i], 1)
a = x - 1
lst[j] = B.sum(y) - B.sum(x - 1)
print(*lst, sep="\n")
| p02599 |
N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
x.sort()
y.sort()
if y[0]>x[N-1] and y[0]>X and x[N-1]<Y:
print('No War')
else:
print('War') | N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
x.sort()
y.sort()
for i in range(x[N-1]+1,y[0]+1):
if i>X and i<=Y:
print('No War')
exit()
print('War') | p03251 |
# coding: utf-8
N, M, X, Y = list(map(int, input().split()))
x = max(list(map(int, input().split())))
y = min(list(map(int, input().split())))
ans = "War"
for z in range(X+1, Y+1):
if x < z <= y:
ans = "No War"
print(ans) | # coding: utf-8
N, M, X, Y = list(map(int, input().split()))
lst_x = list(map(int, input().split()))
lst_x.append(X)
lst_y = list(map(int, input().split()))
lst_y.append(Y)
x = max(lst_x)
y = min(lst_y)
ans = "War"
if x < y:
ans = "No War"
print(ans) | p03251 |
n,m,X,Y = list(map(int,input().split()))
x = max(list(map(int,input().split())))
y = min(list(map(int,input().split())))
if X<x<y<=Y:print('No War')
else:print('War') | n,m,x,y = list(map(int,input().split()))
x_max = sorted(list(map(int,input().split())))[-1]
y_min = sorted(list(map(int,input().split())))[0]
if x<=x_max<y_min<=y:
print('No War')
else:
print('War') | p03251 |
n,m,x,y=list(map(int,input().split()));a,b=list(map(int,input().split())),list(map(int,input().split()));a.sort();b.sort();print(("No War"if max(a[-1],x)<min(y,b[0])else"War")) | n,m,x,y=list(map(int,input().split()))
x=list(map(int,input().split()))+[x]
y=list(map(int,input().split()))+[y]
if max(x)<min(y):print("No War")
else:print("War")
| p03251 |
# 2019-11-10 15:45:20(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n, m, X, Y = (int(i) for i in sys.stdin.readline().split())
x = [int(x) for x in sys.stdin.readline().split()]
y = [int(y) for y in sys.stdin.readline().split()]
max_x = max(x + [X])
min_y = min(y + [Y])
if Y - X < 1 or min_y - max_x < 1:
ans = 'War'
else:
ans = 'No War'
print(ans)
if __name__ == "__main__":
main()
| import sys
n, m, X, Y = list(map(int, sys.stdin.readline().split()))
*x, = list(map(int, sys.stdin.readline().split()))
*y, = list(map(int, sys.stdin.readline().split()))
def main():
return 'No War' if max(X, max(x)) < min(Y, min(y)) else 'War'
if __name__ == '__main__':
ans = main()
print(ans) | p03251 |
N,M,X,Y=list(map(int,input().split()))
x=max(list(map(int,input().split())))
y=min(list(map(int,input().split())))
P=0
for i in range(X+1,Y+1) :
if X < i and i <=Y and x < i and i <= y :
print("No War")
break
else:
print("War") | N,M,X,Y=list(map(int,input().split()))
x=max(list(map(int,input().split())))
y=min(list(map(int,input().split())))
P=0
for i in range(X+1,Y+1) :
if x < i and i <= y :
print("No War")
break
else:
print("War") | p03251 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, X, Y, x, y):
mx = max(x)
my = min(y)
error_print(mx, my)
if mx < my and (my > X and mx < Y):
return 'No War'
return 'War'
def main():
N, M, X, Y = read_int_n()
x = read_int_n()
y = read_int_n()
print(slv(N, M, X, Y, x, y))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, X, Y, x, y):
mx = max(x)
my = min(y)
error_print(mx, my)
if mx >= my:
return 'War'
for i in range(mx+1, my+1):
if X < i <= Y:
return 'No War'
return 'War'
def main():
N, M, X, Y = read_int_n()
x = read_int_n()
y = read_int_n()
print(slv(N, M, X, Y, x, y))
if __name__ == '__main__':
main()
| p03251 |
n,m,x,y = list(map(int,input().split()))
xl = list(map(int,input().split()))
yl = list(map(int,input().split()))
xl.sort(reverse = True)
yl.sort()
if xl[0] < yl[0]:
p = yl[0]
while p > x:
if x < p and p <= y:
print('No War')
exit(0)
print('War')
else:
print('War') | n,m,x,y = list(map(int,input().split()))
xl = list(map(int,input().split()))
yl = list(map(int,input().split()))
xl.append(x)
yl.append(y)
xl.sort()
yl.sort()
if xl[-1] < yl[0]:
print('No War')
else:
print('War') | p03251 |
n,m,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.append(X)
y.append(Y)
x.sort()
y.sort()
if x[-1] < y[0]:
print("No War")
else:
print("War") | n,m,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.append(X)
y.append(Y)
if max(x) < min(y):
print("No War")
else:
print("War") | p03251 |
n,m,x,y=list(map(int,input().split()))
xl=list(map(int,input().split()))
yl=list(map(int,input().split()))
xl.append(x)
yl.append(y)
if max(xl) < min(yl) and x < y:
print('No War')
else:
print('War') | n,m,x,y=list(map(int,input().split()))
xl=list(map(int,input().split()))
yl=list(map(int,input().split()))
xl.append(x)
yl.append(y)
if max(xl) < min(yl):
print('No War')
else:
print('War') | p03251 |
n,m,x,y = list(map(int,input().split()))
xs = max(list(map(int,input().split())))
ys = min(list(map(int,input().split())))
ans = 'War'
if xs+1 <= ys:
for i in range(xs+1,ys+1):
if x < i <= y:
ans = 'No War'
break
print(ans) | n, m, x, y = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
xs.append(x)
ys.append(y)
print(('No War' if max(xs) < min(ys) else 'War')) | p03251 |
N,M,X,Y = list(map(int, input().split()))
Xx = [int(x) for x in input().split()]
Yy = [int(x) for x in input().split()]
mxx = max(Xx)
mny = min(Yy)
if mxx < mny and X < mny and mxx < Y:
print("No War")
else:
print("War")
| N,M,X,Y = list(map(int, input().split()))
Xx = [int(x) for x in input().split()]
Yy = [int(x) for x in input().split()]
def f():
mxx = max(Xx)
mny = min(Yy)
for z in range(Y, X, -1):
if mxx < z and z <= mny:
return "No War"
return "War"
print((f())) | p03251 |
n,m,x,y= list(map(int,input().split()))
lix=list(map(int,input().split()))
liy=list(map(int,input().split()))
lix.append(x)
liy.append(y)
if max(lix) < min(liy):
print("No War")
else:
print("War")
| n,m,x,y= list(map(int,input().split()))
lix=list(map(int,input().split()))
liy=list(map(int,input().split()))
lix.append(x)
liy.append(y)
lix.sort()
liy.sort()
if lix[n] < liy[0]:
print("No War")
else:
print("War")
| p03251 |
N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
can=False
for Z in range(X+1,Y+1):
if max(x)<Z<=min(y):
can=True
if can:
print("No War")
else:
print("War") | N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
xmin=max(x)
ymin=min(y)
for i in range(X+1,Y+1):
if xmin<i<=ymin:
print("No War")
quit()
print("War")
| p03251 |
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
ans = 1
if X >= Y:
ans = 1
elif X < Y:
z = list(range(X+1, Y+1))
for i in z:
if max(x) < i and i <= min(y):
ans = 0
if ans == 0:
print('No War')
else:
print('War') | N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
zx = list(range(max(x)+1,101))
zy = list(range(-100, min(y)+1))
kanou = set(zx) & set(zy)
if len(kanou) == 0:
print('War')
else:
for i in kanou:
if X < i <= Y:
print('No War')
break
else:
print('War') | p03251 |
if __name__ == '__main__':
n,m,X,Y = list(map(int,input().split()))
x = list(map(int,input().split()))
y = list(map(int,input().split()))
x_max = max(x)
y_min = min(y)
flg = False
for Z in range(X+1,Y+1):
if x_max < Z <= y_min:
flg = True
break
if flg:
print("No War")
else:
print("War") | if __name__ == '__main__':
n,m,x,y = list(map(int,input().split()))
X = list(map(int,input().split()))
Y = list(map(int,input().split()))
X.sort()
Y.sort()
flg = False
#xの場所がYのFROM-に入っていないこと
if (Y[0] <= x):
flg = True
#yの場所がXのFROM-に入っていないこと
elif (y <= X[n-1]):
flg = True
#Xの右端とYの左端が交わらないこと
elif (X[n-1] >= Y[0]):
flg = True
if flg:
print("War")
else:
print("No War")
| p03251 |
def nl(): return list(map(int, input().split()))
# print('Yes' if a else 'No')
N, M, X, Y = nl()
x = nl()
y = nl()
flg = False
for i in range(X + 1, Y + 1):
if max(x) < i and i <= min(y):
flg = True
break
print(('No War' if flg else 'War'))
| N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split())) + [X]
y = list(map(int, input().split())) + [Y]
x_max = max(x)
y_min = min(y)
if x_max >= y_min:
war_happen = True
else:
war_happen = False
print(('War' if war_happen else 'No War')) | p03251 |
n, m, xx, yy = list(map(int, input().split()))
x = sorted(list(map(int, input().split())))
y = sorted(list(map(int, input().split())))
if x[-1] < y[0]:
if xx < y[0] and yy > x[-1]:
print("No War")
else:
print("War")
else:
print("War") | n, m, xx, yy = list(map(int, input().split()))
x = sorted(list(map(int, input().split())))
y = sorted(list(map(int, input().split())))
for i in range(xx + 1, yy):
if x[-1] < i <= y[0]:
print("No War")
break
else:
print("War") | p03251 |
A=list(map(int,input().split()))
X=list(map(int,input().split()))
Y=list(map(int,input().split()))
x=max(X)
y=min(Y)
if x<y and A[2]<A[3] and A[2]<y and x<A[3]:
print("No War")
else:
print("War")
| N,M,X,Y=list(map(int,input().split()))
x=list(map(int,input().split()))
y=list(map(int,input().split()))
x=x+[X]
y=y+[Y]
if max(x)<min(y):
print("No War")
else:
print("War") | p03251 |
N,M,X,Y = [int(x) for x in input().split()]
xl = [int(x) for x in input().split()]
yl = [int(x) for x in input().split()]
xl.sort()
yl.sort()
xmax = xl[-1]
ymin = yl[0]
war = 'War'
nowar = 'No War'
isOk = False
if xmax < ymin:
isOk = True
else:
print(war)
exit()
if X < ymin and Y > xmax:
isOk = True
else:
print(war)
exit()
print(nowar)
| N,M,X,Y = [int(x) for x in input().split()]
xl = [int(x) for x in input().split()]
yl = [int(x) for x in input().split()]
xl.sort()
yl.sort()
xmax = xl[-1]
ymin = yl[0]
war = 'War'
nowar = 'No War'
kyokai = xmax + 1
isOk = False
if xmax < ymin:
isOk = True
else:
print(war)
exit()
if kyokai <= ymin:
pass
else:
print(war)
exit()
if X < kyokai:
pass
else:
print(war)
exit()
if kyokai <= Y:
pass
else:
print(war)
exit()
print(nowar) | p03251 |
def bogosort(l):
import random
while 1:
random.shuffle(l)
for i in range(1,len(l)):
if l[i]<l[i-1]:
break
else:
return l
i=lambda:list(map(int,input().split()))
n,m,x,y=i()
if bogosort(i()+[x])[-1]<bogosort(i()+[y])[0]:
print('No War')
else:
print('War') | (*z,X,Y),x,y=eval('map(int,input().split()),'*3);print(('No War'[3*(max(X,*x)>=min(Y,*y)):])) | p03251 |
def main():
import sys
input = sys.stdin.readline
n, m, x, y = list(map(int, input().rstrip('\n').split()))
X = list(map(int, input().rstrip('\n').split()))
Y = list(map(int, input().rstrip('\n').split()))
mx = max(X)
my = min(Y)
for z in range(x + 1, y + 1):
if mx < z <= my:
print("No War")
exit()
print("War")
if __name__ == '__main__':
main()
| def slove():
import sys
input = sys.stdin.readline
n, m, x, y = list(map(int, input().rstrip('\n').split()))
mx = max(list(map(int, input().rstrip('\n').split())))
my = min(list(map(int, input().rstrip('\n').split())))
for i in range(x + 1, y + 1):
if mx < i <= my:
print("No War")
exit()
print("War")
if __name__ == '__main__':
slove()
| p03251 |
n,m,x,y = list(map(int,input().split()))
x1 = max([int(i) for i in input().split()]) + 1
y1 = min([int(i) for i in input().split()])
if x1 <= y1 and x1 <= y and y1 > x:
print('No War')
else:
print('War') | n,m,x,y = list(map(int,input().split()))
x1 = max(list(map(int,input().split()))) + 1
y1 = min(list(map(int,input().split())))
if x1 <= y1 and x1 <= y and y1 > x:
print('No War')
else:
print('War') | p03251 |
def m_i():
return list(map(int, input().split()))
N,M,X,Y = m_i()
Z = max(m_i()) + 1
min_y = min(m_i())
print(("No War" if (X < Z) and (Z <= min_y) and (Z <= Y) else "War")) | def m_i():
return list(map(int, input().split()))
N,M,X,Y = m_i()
Z = max(m_i()) + 1
min_y = min(m_i())
print(("No War" if (X < Z) and (Z <= min(min_y,Y)) else "War")) | p03251 |
N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
ans = 'War'
for z in range(X+1, Y+1):
if len(list([x for x in x if x < z])) == N and len(list([x for x in y if x >= z])) == M:
ans = 'No War'
break
print(ans)
| N, M, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
ans = 'War'
for z in range(X+1, Y+1):
if max(x) < z and min(y) >= z:
ans = 'No War'
break
print(ans)
| p03251 |
n, m, x, y = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
print(("No War" if max([x] + list(xs)) < min([y] + list(ys)) else "War")) | n, m, x, y = list(map(int, input().split()))
xs = list(map(int, input().split()))
ys = list(map(int, input().split()))
print(("No War" if max(x, *xs) < min(y, *ys) else "War")) | p03251 |
n,m,x,y = list(map(int,input().split()))
X = list(map(int,input().split()))
Y = list(map(int,input().split()))
X = sorted(X)
Y = sorted(Y)
for i in range(x+1,y+1):
if X[-1]<i and Y[0]>=i:
print('No War')
exit()
print('War')
| n,m,x,y = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a = max(a)
b = min(b)
for z in range(x+1,y+1):
if a < z <= b:
print('No War')
exit()
print('War')
| p03251 |
N,M,X,Y = list(map(int,input().split()))
x_list = list(map(int,input().split()))
y_list = list(map(int,input().split()))
for i in range(max(x_list)+1,min(y_list)+1):
if i > X and i <= Y and max(x_list) < i and min(y_list) >= i:
print('No War')
break
else:
print('War') | n,m,X,Y = list(map(int,input().split()))
x = sorted(map(int,input().split())) + [X]
y = sorted(map(int,input().split())) + [Y]
print(("No War" if max(x) < min(y) else "War")) | p03251 |
N, M, X, Y = list(map(int, input().split()))
xlist = list(map(int, input().split()))
ylist = list(map(int, input().split()))
xmax = max(xlist)
ymin = min(ylist)
if xmax<ymin:
for z in range(xmax+1, ymin+1):
if X<z<=Y:
print("No War")
break
else:
print("War")
else:
print("War")
| N, M, X, Y = list(map(int, input().split()))
xs = list(map(int, input().split()))
xs.append(X)
ys = list(map(int, input().split()))
ys.append(Y)
xmax = max(xs)
ymin= min(ys)
if xmax<ymin:
print("No War")
else:
print("War")
| p03251 |
N, M, X, Y = list(map(int,input().split()))
x = list(map(int,input().split()))
y = list(map(int,input().split()))
max_x = max(x)
min_y = min(y)
for i in range(X+1, Y+1):
if(max_x < i <= min_y):
print("No War")
break
else:
print("War") | N, M, X, Y = list(map(int,input().split()))
x = sorted(list(map(int,input().split())))
y = sorted(list(map(int,input().split())))
for i in range(X+1, Y+1):
if(x[-1] < i <= y[0]):
print("No War")
break
else:
print("War") | p03251 |
n, m, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.sort(reverse=True)
xmax = max(x[0], X)
y.sort()
ymin = min(y[0], Y)
if ymin - xmax > int(0):
print("No War")
else:
print("War")
| n, m, X, Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.sort(reverse=True)
xmax = max(x[0], X)
y.sort()
ymin = min(y[0], Y)
if ymin - xmax > 0:
print("No War")
else:
print("War")
| p03251 |
N,M,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
if(max(x) < min(y) and X < min(y) and max(x) < Y ):
print("No War")
else:
print("War") | N,M,X,Y = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list(map(int, input().split()))
x.append(X)
y.append(Y)
if(max(x) < min(y)):
print("No War")
else:
print("War") | p03251 |
n, m, x, y = list(map(int, input().split()))
X = [int(i) for i in input().split()]
Y = [int(i) for i in input().split()]
X.append(x)
Y.append(y)
if max(X) < min(Y):
print('No War')
else:
print('War') | n, m, x, y = list(map(int, input().split()))
X = [int(i) for i in input().split()]
Y = [int(i) for i in input().split()]
X.append(x)
Y.append(y)
X.sort()
Y.sort()
print(('War' if max(X) >= min(Y) else 'No War')) | p03251 |
# https://beta.atcoder.jp/contests/abc110/tasks/abc110_b
def solve():
_, _, x, y = list(map(int, input().split()))
Xn = max(list(map(int, input().split())))
Ym = min(list(map(int, input().split())))
for z in range(x + 1, y + 1):
if Xn < z <= Ym:
print('No War')
exit()
else:
print('War')
if __name__ == '__main__':
solve()
| # https://beta.atcoder.jp/contests/abc110/tasks/abc110_b
def solve():
_, _, X, Y = list(map(int, input().split()))
xn = max(list(map(int, input().split())))
ym = min(list(map(int, input().split())))
Z = xn + 1
if X < Z <= Y and xn < Z <= ym:
print('No War')
exit()
else:
print('War')
if __name__ == '__main__':
solve()
| p03251 |
n,m,x,y=input().split()
n,m,x,y=int(n),int(m),int(x),int(y)
x1=input().split()
x2=[]
for i in range(n):
x2.append(int(x1[i]))
y1=input().split()
y2=[]
for i in range(m):
y2.append(int(y1[i]))
s="War"
if y>x:
for i in range(y-x):
if x+i+1>max(x2) and min(y2)>=x+i+1:
s="No War"
print(s)
| n,m,x,y=list(map(int,input().split()))
X=max(list(map(int,input().split())))
Y=min(list(map(int,input().split())))
for z in range(x+1,y+1):
if X<z<=Y:
print("No War")
break
else:
print("War")
| p03251 |
while 1:
n,a,b,c,x=list(map(int,input().split()))
if n==0:break
reel=list(map(int,input().split()))
roop,i=-1,0
while i<n:
roop+=1
if roop>10000:
roop=-1
break
if x==reel[i]:
i+=1
x=(a*x+b)%c
print(roop) | while True:
N,A,B,C,X = list(map(int,input().split()))
if N == A == B == C == X == 0:break
sum = 0
Z = 0
Y = [int(x) for x in input().split()]
if X == Y[0]:
Y.pop(0)
if len(Y) == 0:
Z = 1
while Z == 0:
if sum == 10000:
sum = -2
Z = 1
sum += 1
X = (A*X+B)%C
if X == Y[0]:
Y.pop(0)
if len(Y) == 0:
Z = 1
print(sum) | p01267 |
import copy
from itertools import combinations
N=int(eval(input()))
S=list(input()[0] for _ in range(N))
cS=copy.deepcopy(S)
ans=0
for i in cS:
if i not in ['M', 'A', 'R', 'C', 'H']:
S.remove(i)
P=list(combinations(S,3))
for i in P:
if len(set(i))==3:
ans+=1
print(ans) | N=int(eval(input()))
S=list(input()[0] for _ in range(N))
m=S.count('M')
a=S.count('A')
r=S.count('R')
c=S.count('C')
h=S.count('H')
print((m*a*r+m*a*c+m*a*h
+m*r*c+m*r*h
+m*c*h
+a*r*c+a*r*h
+a*c*h
+r*c*h)) | p03425 |
# ABC089C - March
from itertools import combinations
def main():
n = int(eval(input()))
lst = [input().rstrip() for _ in range(n)]
cond = {"M": 0, "A": 0, "R": 0, "C": 0, "H": 0}
for i in lst:
if i[0] in "MARCH":
cond[i[0]] += 1
ans = 0
for x, y, z in combinations("MARCH", 3):
ans += cond[x] * cond[y] * cond[z]
print(ans)
if __name__ == "__main__":
main() | # ABC089C - March
import sys
input = sys.stdin.readline
from itertools import combinations
def main():
n = int(eval(input()))
lst = [input().rstrip() for _ in range(n)]
cond = {"M": 0, "A": 0, "R": 0, "C": 0, "H": 0}
for i in lst:
if i[0] in "MARCH":
cond[i[0]] += 1
ans = 0
for x, y, z in combinations("MARCH", 3):
ans += cond[x] * cond[y] * cond[z]
print(ans)
if __name__ == "__main__":
main() | p03425 |
from collections import *
d=Counter()
for _ in range(int(eval(input()))): d[input()[0]]+=1
import itertools as it
print((sum(d[s]*d[t]*d[r] for s,t,r in it.combinations('MARCH',3)))) | l=[input()[0] for _ in range(int(eval(input())))]
import itertools as it
print((sum(x*y*z for x,y,z in it.combinations([l.count(c) for c in 'MARCH'],3)))) | p03425 |
from itertools import combinations
n = int(eval(input()))
march = ("M","A","R","C","H")
d = []
for _ in range(n):
pre = input()[0]
if pre in march: d.append(pre)
if len(d) < 3:
print((0))
exit()
ans = 0
for i in combinations(d,3):
if len(set(i)) == 3:
ans += 1
print(ans) | n = int(eval(input()))
march = ("M","A","R","C","H")
prefix = []
d = {}
for _ in range(n):
pre = input()[0]
if pre in march:
if pre not in prefix:
prefix.append(pre)
d[pre] = 1
else:
d[pre] += 1
t = len(prefix)
if t < 3:
print((0))
exit()
ans = 0
for i in range(t-2):
for j in range(i+1, t-1):
for k in range(j+1,t):
ans += d[prefix[i]]*d[prefix[j]]*d[prefix[k]]
print(ans) | p03425 |
import sys
from collections import Counter
from itertools import combinations
MARCH = set('MARCH')
n = int(sys.stdin.readline().rstrip())
s = [x[0] for x in sys.stdin.read().split() if x[0] in MARCH]
def main():
c = Counter(s)
ways = 0
for comb in combinations('MARCH', 3):
res = 1
for i in comb:
res *= c.get(i, 0)
ways += res
return ways
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from collections import Counter
from itertools import combinations
n, *s = [s[0] for s in sys.stdin.read().split()]
def main():
c = Counter(s)
res = 0
for i, j, k in combinations('MARCH', 3):
res += c[i] * c[j] * c[k]
print(res)
if __name__ == '__main__':
main() | p03425 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.