HDU3874Necklace（树状数组+离线操作）

此题的大意思说有一串珠子，每个珠子都有自己的欣赏值value，现在给你一串珠子每个的欣赏值，并给出一些询问，查询某个区间内部总欣赏值是多少，但是有一个约定就是如果这个区间内部有两个珠子的欣赏值是一样的，那么他们就视为一个。

其实也就是求某个区间内部不同的数的和。

这里学到了一个比较好的方法，那就是离线操作。根据我的理解，离线操作就是为了解决在询问中所遇到的矛盾的，它在本题上的实现就是先将查询排序，比如按照每个查询的右端点的升序排序，这样的话每次查询一个区间的时候，我们就把它的右端点到上一个查询的右端点之间且在之前已经出现过了相同价值的点删除掉，这样的话就可以保证对后面的查询不会有影响。

具体实现就是用一个last[]数组保存每一个value值最初出现的位置，再用一个Right保存上次扫描的区间的右端点（初始化为1，下图中的R表示），每次查询一个区间的和时，先按照Right到这个区间右端点扫描一遍，如果当中有一个value值上次出现的位置不在它自己的位置时，如下图第2个1之前出现的位置L[1]=1，那么我们就把第一个1从树状数组里面去掉，然后同时更新L[1]为当前位置L[1]=2.这样一来当前的1之前就可以保证没有重复的1。而且下次找到另外一个1时，也只会删除位置为2的1.

同时我们还要更新Right值为当前区间的右端点（因为之前区间已经没有重复的了）

aaarticlea/png;base64,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" alt="" width="597" height="245" />

同时，由于是按照右端点的升序排列，所以可能会用到之前的1或者不用，用的话同样保证了只有1个1，所以这样排序是对的

 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #define mem(a) memset(a,0,sizeof(a))
 #define MAX(a , b) ((a) > (b) ? (a) : (b))
 using namespace std;

 struct QUERY
 {
     int a,b;
     int index;
 }query[];
 __int64 c[],  ans[];
 int last[], value[], N, M, T;

 int cmp(QUERY x, QUERY y)
 {
     return x.b < y.b;
 }

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

 __int64 getSum(int k)
 {
     __int64 sum = ;
     while(k>=)
     {
         sum += c[k];
         k -= lowbit(k);
     }
     return sum;
 }

 void edit(int k, int val)
 {
     while(k<=N)
     {
         c[k] += val;
         k += lowbit(k);
     }
 }

 int main()
 {
     while(~scanf("%d", &T))while(T--)
     {
         mem(query);  mem(c);
         mem(last);   mem(ans);
         mem(value);
         scanf("%d", &N);
         for(int i=;i<=N;i++)
         {
             scanf("%d", &value[i]);
             edit(i, value[i]);
             if(!last[value[i]]) last[value[i]] = i;
         }
         scanf("%d", &M);
         for(int i=;i<=M;i++)
         {
             scanf("%d%d", &query[i].a, &query[i].b);
             query[i].index = i;
         }
         sort(query+, query+M+, cmp);
         int lastRight = ;
         for(int i = ; i <= M; i ++)
         {
             for(int j = lastRight; j <= query[i].b; j ++)
             {
                 if(last[value[j]] != j)
                 {
                     edit(last[value[j]], -value[j]);
                     last[value[j]] = j;
                 }
             }
             lastRight = query[i].b;
             ans[query[i].index] = getSum(query[i].b) - getSum(query[i].a-);
         }
         for(int i=;i<=M;i++)
         {
             printf("%I64d\n", ans[i]);
         }
     }
     return ;
 }