HDU3874 /HDU3333 树状数组 区间求不重复数和

Necklace

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 4604    Accepted Submission(s): 1581

Problem Description

Mery
has a beautiful necklace. The necklace is made up of N magic balls.
Each ball has a beautiful value. The balls with the same beautiful value
look the same, so if two or more balls have the same beautiful value,
we just count it once. We define the beautiful value of some interval
[x,y] as F(x,y). F(x,y) is calculated as the sum of the beautiful value
from the xth ball to the yth ball and the same value is ONLY COUNTED
ONCE. For example, if the necklace is 1 1 1 2 3 1, we have F(1,3)=1,
F(2,4)=3, F(2,6)=6.

Now Mery thinks the necklace is too long. She
plans to take some continuous part of the necklace to build a new one.
She wants to know each of the beautiful value of M continuous parts of
the necklace. She will give you M intervals [L,R] (1<=L<=R<=N)
and you must tell her F(L,R) of them.

 

Input

The first line is T(T<=10), representing the number of test cases.
  For
each case, the first line is a number N,1 <=N <=50000, indicating
the number of the magic balls. The second line contains N non-negative
integer numbers not greater 1000000, representing the beautiful value of
the N balls. The third line has a number M, 1 <=M <=200000,
meaning the nunber of the queries. Each of the next M lines contains L
and R, the query.

 

Output

For each query, output a line contains an integer number, representing the result of the query.

 

Sample Input

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

 

Sample Output

3
7
14
1
3
6

 

Source

2011 Multi-University Training Contest 4 - Host by SDU

题意：
给一串数，若干询问，每次询问一个区间内不重复数字之和。

代码：

 /*
 把询问的几个区间先存起来，将其按照区间右端点从小到大排序，这样当去掉某一区间内的重复值时就不会
 影响其他区间，因为其他区间的右端点要么比他小，要么比他大，比他小的不会受影响（树状数组向上更新）
 ，比他大的恰好也要去重。去重时利用map。
 */
 #include<iostream>
 #include<cstdio>
 #include<map>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 const int MAXN=;
 const int MAXM=;//MAXM,MAXN改为30005，1000005就是HDU3333题题解
 long long A[MAXN];
 long long NE[MAXN];
 int t,n,m;
 struct Necklace
 {
     int R,L,id;//区间右端点，区间左端点，序号
 }neck[MAXM];
 bool cmp(Necklace a,Necklace b)
 {
     if(a.R==b.R)
     return a.L<b.L;
     else return a.R<b.R;
 }
 int lowbit(int x)
 {
     return x&(-x);
 }
 void add(int id,long long c)
 {
     while(id<=MAXN)
     {
         A[id]+=c;
         id+=lowbit(id);
     }
 }
 long long sum(int id)
 {
     long long s=;
     while(id>)
     {
         s+=A[id];
         id-=lowbit(id);
     }
     return s;
 }
 using namespace std;
 int main()
 {
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&n);
         for(int i=;i<=n;i++)
         scanf("%lld",&NE[i]);
         scanf("%d",&m);
         for(int i=;i<m;i++)
         {
             scanf("%d%d",&neck[i].L,&neck[i].R);
           //  if(neck[i].L>neck[i].R)
           //  swap(neck[i].L,neck[i].R);
             neck[i].id=i;
         }
         sort(neck,neck+m,cmp);
         int p=;
         map<int,int>mp;
         long long ans[MAXM];
         memset(A,,sizeof(A));
         for(int i=;i<m;i++)
         {
             while(p<=neck[i].R)//小于等于区间右端点的
             {
                 long long x=NE[p];
                 if(mp[x]!=)//如果前面出现过此X值就减去旧的加上新的
                 add(mp[x],-x);
                 add(p,x);
                 mp[x]=p;
                 p++;
             }
             ans[neck[i].id]=sum(neck[i].R)-sum(neck[i].L-);
         }
         for(int i=;i<m;i++)
         printf("%lld\n",ans[i]);
     }
     return ;
 }