此题的大意思说有一串珠子，每个珠子都有自己的欣赏值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 ;
}