Given a sequence of n numbers a1, a2, …, an and a number of d-queries. A d-query is a pair (i, j) (1 ≤ i ≤ j ≤ n). For each d-query (i, j), you have to return the number of distinct elements in the subsequence ai, ai+1, …, aj.
Input
Line 1: n (1 ≤ n ≤ 30000).
Line 2: n numbers a1, a2, …, an (1 ≤ ai ≤ 106).
Line 3: q (1 ≤ q ≤ 200000), the number of d-queries.
In the next q lines, each line contains 2 numbers i, j representing a d-query (1 ≤ i ≤ j ≤ n).
Output
For each d-query (i, j), print the number of distinct elements in the subsequence ai, ai+1, …, aj in a single line.

Example
Input
5
1 1 2 1 3
3
1 5
2 4
3 5

Output
3
2
3
题意就是查询区间不同元素的个数，有两种解法。
解法1：离线+树状数组，先把询问离线，并且按照右端点排序，然后从小区间开始，然后树状数组的含义就是指以当前r为结尾的前缀区间的元素种类数，简单点说，就是我当前扫到l , r区间，把l - r区间还没在树状数组上更新的值，更新一遍，在之前已经存在了的值先删掉再更新一遍，确保我确定的元素都是往r靠的，这样才能保证求取区间正确。举个栗子吧：比如我 1 2 2 1 3，当我r移到3的时候，加入前面的1还没在树状数组里更新过（但其实之前已经有读过1了）那就把之前的1的影响删掉，重新在这个3左边这个下标为4的位置给树状数组 add 1.这样确保之后不管我是查询 4 5 或者 1 5，元素1都只算了一次，但都没遗落（想想如果元素1一直在下标1那里，我查询4 5，就不会有1了）

//SPOJ DQUER 170ms 34816kb
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int maxq = 1000010;
map <int, int> mp; //记录第一次出现的位置
struct Q{
    int l, r, id;
    Q(){}
    Q(int l, int r, int id) : l(l), r(r), id(id){}
}q[maxq];
bool cmp(Q a, Q b){
    return a.r < b.r;
}
namespace BIT{
    int sum[maxn], n, m;
    inline void init(){memset(sum, 0, sizeof(sum));}
    inline int lowbit(int x){return x & -x;}
    inline void add(int i, int v){for(;i <= n; i+=lowbit(i)) sum[i] += v;}
    inline int query(int i){int res = 0; for(; i; i-=lowbit(i)) res += sum[i]; return res;}
}
using namespace BIT;
int a[maxn], ans[maxq];
int main(){
    while(scanf("%d", &n) != EOF){
        mp.clear();
        for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
        scanf("%d", &m);
        for(int i = 1; i <= m; i++){
            scanf("%d%d", &q[i].l, &q[i].r); q[i].id = i;
        }
        sort(q + 1, q + m + 1, cmp);
        int cur = 1;
        for(int i = 1; i <= m; i++){
            int id = q[i].id;
            for(int j = cur; j <= q[i].r; j++){
                if(mp.find(a[j]) != mp.end()){
                    add(mp[a[j]], -1);
                }
                add(j, 1);
                mp[a[j]] = j;
            }
            cur = q[i].r + 1;
            ans[id] = query(q[i].r) - query(q[i].l - 1);
        }
        for(int i = 1; i <= m; i++) printf("%d\n", ans[i]);
    }
    return 0;
}

解法2：有了主席树我们为什么要离线呢？对不对。对于一个数，如果以前没出现过，就插入到主席树中，否则就删除以前那个，再插入主席树。注意，所有的更新和删除都是建立了新的节点来保持其历史状态的。对于T[i]我们存的是从1到i区间的不同的数出现了多少个。然后这棵树是根据T[i - 1]来建立的。

//200ms 34816kb
//SPOJ DQUERY
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30010;
int n, q, tot, a[maxn], nxt[maxn], b[maxn];
int T[maxn*40], lson[maxn*40], rson[maxn*40], val[maxn*40];
int build(int l, int r){
    int rt = tot++; val[rt] = 0;
    int mid = (l + r) / 2;
    if(l != r){
        lson[rt] = build(l, mid);
        rson[rt] = build(mid + 1, r);
    }
    return rt;
}
int update(int root, int pos, int v){
    int newroot = tot++, tmp = newroot;
    int l = 1, r = n;
    val[newroot] = val[root] + v;
    while(l < r){
        int m = (l + r) / 2;
        if(pos <= m){
            lson[newroot] = tot++; rson[newroot] = rson[root];
            newroot = lson[newroot]; root = lson[root]; r = m;
        }
        else{
            rson[newroot] = tot++; lson[newroot] = lson[root];
            newroot = rson[newroot]; root = rson[root]; l = m + 1;
        }
        val[newroot] = val[root] + v;
    }
    return tmp;
}
int query(int root, int pos){
    int ret = 0;
    int l = 1, r = n;
    while(l < pos){
        int m = (l + r) / 2;
        if(pos <= m){
            ret += val[rson[root]];
            root = lson[root];
            r = m;
        }
        else{
            l = m + 1;
            root = rson[root];
        }
    }
    return ret + val[root];
}
int main()
{
    while(scanf("%d", &n) != EOF)
    {
        tot = 0;
        memset(nxt, -1, sizeof(nxt));
        for(int i = 1; i <= n; i++){
            scanf("%d", &a[i]);
            b[i-1] = a[i];
        }
        //lisanhua
        sort(b, b+n);
        int cnt = unique(b, b + n)- b;
        T[0] = build(1, n);
        for(int i = 1; i <= n; i++){
            int id = lower_bound(b, b+cnt, a[i]) - b;
            if(nxt[id] == -1){
                T[i] = update(T[i - 1], i, 1);
            }
            else{
                int t  = update(T[i-1], nxt[id], -1);
                T[i] = update(t, i, 1);
            }
            nxt[id] = i;
        }
        scanf("%d", &q);
        while(q--){
            int l, r;
            scanf("%d%d", &l, &r);
            printf("%d\n", query(T[r], l));
        }
    }
    return 0;
}