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)

// C++ code to find number of distinct numbers
// in a subarray
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MAX = 1000001;

// structure to store queries
struct Query
{
    ll l, r, idx;
};

// cmp function to sort queries according to r
bool cmp(Query x, Query y)
{
    return x.r < y.r;
}

// updating the bit array
void update(ll idx, ll val, ll bit[], ll n)
{
    for (; idx <= n; idx += idx&-idx)
        bit[idx] += val;
}

// querying the bit array
ll query(ll idx, ll bit[], ll n)
{
    ll sum = 0;
    for (; idx>0; idx-=idx&-idx)
        sum += bit[idx];
    return sum;
}



// driver code
int main()
{
    ll n ,q;
    cin>>n>>q;
    ll a[n];
    for(ll i=0;i<n;i++){
        cin>>a[i];
    }
    Query queries[q];
    for(ll i=0;i<q;i++){
            ll u,v;
    cin>>u>>v;
    queries[0].l = u-1;
    queries[0].r = v-1;
    queries[i].idx = i;
    }
    ll test=2000,pip=0;
    while(test--){
        pip++;
    }
    sort(queries, queries+q, cmp);
    ll bit[n+1]={0};


    // holds the rightmost index of any number
    // as numbers of a[i] are less than or equal to 10^6
    ll last_visit[MAX]={-1};


    // answer for each query
    ll ans[q];
    ll query_counter = 0;
    for (int i=0; i<n; i++)
    {

        if (last_visit[a[i]] !=-1)
            update (last_visit[a[i]] + 1, -1, bit, n);
        last_visit[a[i]] = i;
        update(i + 1, 1, bit, n);

        while (query_counter < q && 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++;
        }
    }

    for (ll i=0; i<q; i++)
        cout << ans[i] << endl;
    return 0;
}