Problem:
Score : 600 points

Problem Statement

We have N colored balls arranged in a row from left to right; the color of the i-th ball from the left is c_i.

You are given Q queries. The i-th query is as follows: how many different colors do the l_i-th through r_i-th balls from the left have?

Constraints

1\leq N,Q \leq 5 \times 10^5

1\leq c_i \leq N

1\leq l_i \leq r_i \leq N

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N Q
c_1 c_2 \cdots c_N
l_1 r_1
l_2 r_2
:
l_Q r_Q

Output

Print Q lines. The i-th line should contain the response to the i-th query.

Sample Input 1

4 3
1 2 1 3
1 3
2 4
3 3

Sample Output 1

2
3
1

The 1-st, 2-nd, and 3-rd balls from the left have the colors 1, 2, and 1 - two different colors.

The 2-st, 3-rd, and 4-th balls from the left have the colors 2, 1, and 3 - three different colors.

The 3-rd ball from the left has the color 1 - just one color.

Sample Input 2

10 10
2 5 6 5 2 1 7 9 7 2
5 5
2 4
6 7
2 2
7 8
7 9
1 8
6 9
8 10
6 8

Sample Output 2

1
2
2
1
2
2
6
3
3
3

Solution in Julia (1.4.0) (judge verdict: Time Limit Exceeded)

struct BIT
	n::Int
	bit::Array{Int}
	BIT(n)=new(n,zeros(Int,n))
end
function sum(bit::BIT,i::Int)
	ans=0
	while i>0
		ans+=bit.bit[i]
		i-=i&-i
	end
	ans
end
function add(bit::BIT,i::Int,a::Int)
	while i<=bit.n
		bit.bit[i]+=a
		i+=i&-i
	end
end
function lower_bound(bit::BIT,k::Int)#k<=sum(ret)
	if k<=0
		return 0
	end
	ret=0
	i=1
	while i*2<=bit.n
		i*=2
	end
	while i>0
		if ret+i<=bit.n&&bit.bit[ret+i]<k
			k-=bit.bit[ret+i]
			ret+=i
		end
		i>>=1
	end
	ret+1
end
function main()
	N,Q=map(x->parse(Int,x),split(readline()))
	C=map(x->parse(Int,x),split(readline()))
	id=zeros(Int,N)
	P=BIT(N)
	Qs=[[] for _=1:N]
	for i=1:Q
		l,r=map(x->parse(Int,x),split(readline()))
		push!(Qs[r],l=>i)
	end
	ans=zeros(Int,Q)
	for r=1:N
		c=C[r]
		if id[c]!=0
			add(P,id[c],-1)
		end
		id[c]=r
		add(P,id[c],1)
		for (l,i)=Qs[r]
			ans[i]=sum(P,r)-sum(P,l-1)
		end
	end
	println.(ans)
end
main()