HDU--3333(树状数组+离线处理）

Turing Tree

Time Limit: 3000MS

Memory Limit: 32768KB

64bit IO Format: %I64d & %I64u

Submit Status

Description

After inventing Turing Tree, 3xian always felt boring when solving problems about intervals, because Turing Tree could easily have the solution. As well, wily 3xian made lots of new problems about intervals. So, today, this sick thing happens again... 

Now given a sequence of N numbers A1, A2, ..., AN and a number of Queries(i, j) (1≤i≤j≤N). For each Query(i, j), you are to caculate the sum of distinct values in the subsequence Ai, Ai+1, ..., Aj.

 

Input

The first line is an integer T (1 ≤ T ≤ 10), indecating the number of testcases below. 
For each case, the input format will be like this: 
* Line 1: N (1 ≤ N ≤ 30,000). 
* Line 2: N integers A1, A2, ..., AN (0 ≤ Ai ≤ 1,000,000,000). 
* Line 3: Q (1 ≤ Q ≤ 100,000), the number of Queries. 
* Next Q lines: each line contains 2 integers i, j representing a Query (1 ≤ i ≤ j ≤ N).

 

Output

For each Query, print the sum of distinct values of the specified subsequence in one line.

 

Sample Input

    
    

     
      2
3
1 1 4
2
1 2
2 3
5
1 1 2 1 3
3
1 5
2 4
3 5 
    
    

 

Sample Output

    
    

     
      1
5
6
3
6 
    
    

 方法挺神奇，是离线处理，离线下各个查询之后按区间右端点排序，不断插入BIT中，如果曾经出现过的数，让原来的位置为0表示没有出现过，将现在的位置加上这个数表示出现，WA好多次，排序的时候没注意排错了，范围没注意，c和ans数组都应该是long long 范围。

代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
#include<set>
#define INF 0x3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int maxd=30000+10;
const int maxn=100000+5;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1 | 1
typedef long long ll;
typedef pair<int,int> pii;
#define eps 1e-10

using namespace std;
//---------------------
typedef long long ll;
int a[maxd];
ll c[maxd];
int op,n,l,r;
struct node
{
    int l,r;
    int id;
    ll _sum;
    bool operator<(node a) const
    {
        if(r!=a.r)
            return r<a.r;
        return l<a.l;
    }
};
node qq[maxn];
ll ans[maxn];
map<int,int> vis;

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

ll sum(int x)
{
    ll ret=0;
    while(x>0)
    {
        ret+=c[x];
        x-=lowbit(x);
    }
    return ret;
}

void add(int x,int d)
{
    while(x<=n)
    {
        c[x]+=d;
        x+=lowbit(x);
    }
}

int main()
{
    int kase;
    freopen("1.txt","r",stdin);
    scanf("%d",&kase);
    while(kase--)
    {
        scanf("%d",&n);

        mem(c,0);
        vis.clear();
        for(int i=1; i<=n; ++i)
            scanf("%d",&a[i]);

        scanf("%d",&op);
        for(int i=1; i<=op; ++i)
            scanf("%d %d",&qq[i].l,&qq[i].r),qq[i].id=i;
        sort(qq+1,qq+1+op);
        qq[0].l=0,qq[0].r=0;
        for(int i=1; i<=op; ++i)
        {
            int ll=qq[i].l,rr=qq[i].r;

            for(int j=qq[i-1].r+1; j<=qq[i].r; ++j)
            {
                if(vis.find(a[j])!=vis.end())
                {
                    add(vis[a[j]],-a[j]);
                }
                add(j,a[j]);
                vis[a[j]]=j;
            }
          
            ans[qq[i].id]=sum(rr)-sum(ll-1);
        }
        for(int i=1; i<=op; ++i)
            printf("%lld\n",ans[i]);
    }
    return 0;
}