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 C++ (GCC 9.2.1) (judge verdict: Runtime Error)

#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double
#define mp make_pair
#define pb push_back
#define pll pair<ll,ll>
ll INF = 1000000007;


//-----------------//
  #define amin main
//-----------------//
set<ll>* segment; 

void build(ll i, ll s, ll e, ll arr[]) 
{ 
  
    
    if (s == e) { 
        segment[i].insert(arr[s]); 
        return; 
    } 
  
  
    build(2 * i, s, (s + e) / 2, arr); 
    build(1 + 2 * i, 1 + (s + e) / 2, e, arr); 
  
    segment[i].insert(segment[2 * i].begin(), 
                      segment[2 * i].end()); 
  
    segment[i].insert(segment[2 * i + 1].begin(), 
                      segment[2 * i + 1].end()); 
} 
  
// Query in an range a to b 
set<ll> query(ll node, ll l, ll r, ll a, ll b) 
{ 
    set<ll> left, right, result; 
  
   
    if (b < l || a > r) 
        return result; 
 
    if (a <= l && r <= b) 
        return segment[node]; 
  
   
    left = query(2 * node, l, (l + r) / 2, a, b); 
    result.insert(left.begin(), left.end()); 
  
    right = query(1 + 2 * node, 1 + (l + r) / 2, r, a, b); 
    result.insert(right.begin(), right.end()); 
  
    
    return result; 
} 

void init(ll n) 
{ 
    
    ll h = (ll)ceil(log2(n)); 
    h = (2 * (pow(2, h))) - 1; 
  
    
    segment = new set<ll>[h]; 
} 
  

void getDistinct(ll l, ll r, ll n) 
{ 
    
    set<ll> ans = query(1, 0, n - 1, l, r); 
  
  ll k = ans.size();
    cout << k << endl; 
} 
int amin()
{
	
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	ll t,i,j;
	
	 ll n,q;
	 cin>>n>>q;
	 ll arr[n];
	 for(i=0;i<n;i++)
	 {
	 	cin>>arr[i];
	 }
	 init(n);
	  //init(n); 
  
    
    build(1, 0, n - 1, arr); 
  
  	while(q--){
  		ll a,b;
  		cin>>a>>b;
  		a--;
  		b--;
  		getDistinct(a,b,n);

  	}
    
	
	
	


	
	return 0;
}