Codeforese 220B Little Elephant and Array

B. Little Elephant and Array

time limit per test

4 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.

Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj(1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.

Help the Little Elephant to count the answers to all queries.

Input

The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj(1 ≤ lj ≤ rj ≤ n).

Output

In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.

Examples

input

Copy

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

output

Copy

3
1
直接莽莫队是不对滴，要离散化一下：）

#include <bits/stdc++.h>
using namespace std;
struct pap
{
    int l;
    int r;
    int id;
}node[100005];
int ma,l,r,n,m,ans;
int a[100005],b[100005],c[100005],str[100005],num[100005];
bool cmp(pap x,pap y)
{
    if(x.l/ma!=y.l/ma)
    {
        return x.l<y.l;
    }
    return x.r<y.r;
}
void update(int n,int k)
{
    if(k==1)
    {
        if(num[a[n]]==c[n]-1)
        {
            ans++;
        }
        else if(num[a[n]]==c[n])
        {
            ans--;
        }
        num[a[n]]++;
    }
    else
    {
        if(num[a[n]]==c[n]+1)
        {
            ans++;
        }
        else if(num[a[n]]==c[n])
        {
            ans--;
        }
        num[a[n]]--;
    }
}
void solve()
{
    memset(num,0,sizeof(num));
    l=1;
    r=0;
    for(int i=1;i<=m;i++)
    {
        while(r<node[i].r)
        {
            update(++r,1);
        }
        while(r>node[i].r)
        {
            update(r--,-1);
        }
        while(l>node[i].l)
        {
            update(--l,1);
        }
        while(l<node[i].l)
        {
            update(l++,-1);
        }
        str[node[i].id]=ans;
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        ma=sqrt(n);
        ans=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            b[i]=c[i]=a[i];
        }
        sort(b+1,b+1+n);
        int len=unique(b+1,b+1+n)-b-1;
        for(int i=1;i<=n;i++)
        {
            a[i]=lower_bound(b+1,b+len+1,a[i])-b;
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&node[i].l,&node[i].r);
            node[i].id=i;
        }
        sort(node+1,node+m+1,cmp);
        solve();
        for(int i=1;i<=m;i++)
        {
            printf("%d\n",str[i]);
        }
    }
}