SPOJ DQUUERY (在线主席树 | 离线树状数组)

DQUERY - D-query

#sorting  #tree

English

Vietnamese

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 

 Submit solution!

题意:询问区间内出现的数字有多少种.

离线和在线的做法都需要记录某一个数字出现的最远的位置.

离线树状数组:

询问按照右端点排序,然后每次从前一次询问的右端点扫描到当前询问的右端点,

每次将数字之前出现的位置的前缀和-1,新位置的前缀和+1,这个前缀和用树状

数组维护下就好了.询问[l,r]区间就是前缀和[1,r]-[1,l-1].

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define maxn 211111

int a[maxn];
int n;
vector <int> num;
map <int , int> gg;
struct node {
    int l, r, id;
    bool operator < (const node &a) const {
        return r < a.r;
    }
}op[maxn];
int ans[maxn], pos[maxn];

void init () {
    int cnt = 0;
    sort (num.begin (), num.end ());
    for (int i = 0; i < n; i++) {
        if (!i || num[i] != num[i-1]) {
            gg[num[i]] = ++cnt;
        }
    }
    for (int i = 1; i <= n; i++) {
        a[i] = gg[a[i]];
    }
}

int c[maxn];

int lowbit (int x) {
    return x&(-x);
}

void add (int pos, int num) {
    for (int i = pos; i <= n; i += lowbit (i))
        c[i] += num;
}

int sum (int pos) {
    int ans = 0;
    for (int i = pos; i > 0; i -= lowbit (i))
        ans += c[i];
    return ans;
}

int main () {
    while (scanf ("%d", &n) == 1) {
        gg.clear ();
        num.clear ();
        for (int i = 1; i <= n; i++) {
            scanf ("%d", &a[i]);
            num.push_back (a[i]);
        }
        init ();
        int q;
        scanf ("%d", &q);
        for (int i = 1; i <= q; i++) {
            scanf ("%d%d", &op[i].l, &op[i].r);
            op[i].id = i;
        }
        sort (op+1, op+1+q);
        memset (c, 0, sizeof c);
        memset (pos, -1, sizeof pos);
        int pre = 0;
        for (int i = 1; i <= q; i++) {
            for (; pre+1 <= op[i].r;) {
                pre++;
                add (pre, 1);
                if (pos[a[pre]] != -1) {
                    add (pos[a[pre]], -1);
                }
                pos[a[pre]] = pre;
            }
            ans[op[i].id] = sum (op[i].r) - sum (op[i].l-1);
        }
        for (int i = 1; i <= q; i++) {
            printf ("%d\n", ans[i]);
        }
    }
    return 0;
}

在线主席树:

记录每一个数字出现的最左边的位置.然后按照从右往左建可持久化线段树,

新增加一个数字就在前一个版本中的他出现的位置-1,新版本他出现的这个位置

+1.然后询问[l,r]的时候就只需要询问l版本线段树[l,r]的区间求和.

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define maxn 211111

struct node {
    int l, r;
    int num;
}tree[maxn<<6];
int T[maxn];
int cnt;//总结点数
int n, q, a[maxn], pre[maxn];
vector <int> num;
map <int , int> gg;

void init () {
    sort (num.begin (), num.end ());
    int cnt = 0;
    for (int i = 0; i < num.size (); i++) {
        if (!i || num[i] != num[i-1]) {
            gg[num[i]] = ++cnt;
        }
    }
    for (int i = 1; i <= n; i++) a[i] = gg[a[i]];
}

int build_tree (int l, int r) {
    int root = cnt++;
    tree[root].num = 0;
    if (l == r)
        return root;
    int mid = (l+r)>>1;
    tree[root].l = build_tree (l, mid);
    tree[root].r = build_tree (mid+1, r);
    return root;
}

int update (int root, int pos, int val) {
    int new_root = cnt++;
    int tmp = new_root;
    tree[new_root].num = tree[root].num+val;
    int l = 1, r = n;
    while (l < r) {
        int mid = (l+r)>>1;
        if (pos <= mid) {
            tree[new_root].l = cnt++;
            tree[new_root].r = tree[root].r;
            new_root = tree[new_root].l;
            root = tree[root].l;
            r = mid;
        }
        else {
            tree[new_root].l = tree[root].l;
            tree[new_root].r = cnt++;
            new_root = tree[new_root].r;
            root = tree[root].r;
            l = mid+1;
        }
        tree[new_root].num = tree[root].num + val;
    }
    return tmp;
}

int query (int root, int l, int r, int x, int y) {
    if (x == l && y == r) {
        return tree[root].num;
    }
    int mid = (l+r)>>1;
    if (mid >= y) {
        return query (tree[root].l, l, mid, x, y);
    }
    else if (mid < x) {
        return query (tree[root].r, mid+1, r, x, y);
    }
    else {
        return query (tree[root].l, l, mid, x, mid) + query (tree[root].r, mid+1, r, mid+1, y);
    }
}

int main () {
    //freopen ("in.txt", "r", stdin);
    while (scanf ("%d", &n) == 1) {
        num.clear ();
        gg.clear ();
        for (int i = 1; i <= n; i++) {
            scanf ("%d", &a[i]);
            num.push_back (a[i]);
        }
        init ();
        cnt = 0;
        memset (pre, -1, sizeof pre);
        T[n+1] = build_tree (1, n);
        for (int i = n; i >= 1; i--) {
            if (pre[a[i]] == -1) {
                T[i] = update (T[i+1], i, 1);
            }
            else {
                int tmp = update (T[i+1], pre[a[i]], -1);
                T[i] = update (tmp, i, 1);
            }
            pre[a[i]] = i;
        }
        int q;
        scanf ("%d", &q);
        while (q--) {
            int l, r;
            scanf ("%d%d", &l, &r);
            printf ("%d\n", query (T[l], 1, n, l, r));
        }
    }
    return 0;
}