hdu 3333 树状数组+离线处理

思路：既然要求的是不同的元素的和，那么我们可以想办法让每个值在区间中只出现一次，于是想到了离线的算法：将查询按照右端点排序，位置在右端点之前的元素都插入到树状数组中，对于已经出现过的值，我们要先删除（在原位置）再插入（在cur的位置），因为很显然对于同一个元素，只有在最靠右的位置出现一次才能返回正确的查询结果。所以我们需要用map来记录每个值上一次插入的位置，删除后再插入到当前位置。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <map>
using namespace std;

typedef long long ll;
const int N = 30001;
const int Q = 100001;
ll c[N];
ll ans[Q];
int a[N];

struct Query
{
    int i, j, id;
    bool operator < ( const Query & o ) const 
    {
        return j < o.j;
    }
} query[Q];

map<int, int> mp;

int lb( int i )
{
    return i & -i;
}

void update( int i, int v )
{
    while ( i < N )
    {
        c[i] += v;
        i += lb(i);        
    }
}

ll get( int i )
{
    ll ans = 0;
    while ( i )
    {
        ans += c[i];
        i -= lb(i);
    }
    return ans;
}

int main ()
{
    int t;
    scanf("%d", &t);
    while ( t-- )
    {
        int n, q;        
        scanf("%d", &n);
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d", a + i);            
        }
        scanf("%d", &q);
        for ( int i = 1; i <= q; i++ )
        {
            scanf("%d%d", &query[i].i, &query[i].j);        
            query[i].id = i;    
        }
        sort( query + 1, query + 1 + q );
        memset( c, 0, sizeof(c) );
        mp.clear();
        int cur = 1;
        for ( int i = 1; i <= q; i++ )
        {
            while ( cur <= query[i].j )
            {
                if ( mp.count(a[cur]) )
                {
                    int pos = mp[a[cur]];
                    update( pos, -a[cur] );
                }
                update( cur, a[cur] );
                mp[a[cur]] = cur;
                cur++;
            }
            ans[query[i].id] = get( query[i].j ) - get( query[i].i - 1 );
        }
        for ( int i = 1; i <= q; i++ )
        {
            printf("%I64d
", ans[i]);
        }
    }
    return 0;
}