HDU-3333-Turing Tree (线段树+动态的区间查询)

题目：

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

题目大意：给定一串数字，求从第i个到j个数之间某区间内相异数字的总和。

思路：动态的进行区间查询。将读入的数放在一个数组里。将操作放在一个结构体中，有操作的头和尾，还有操作的编号（即第几次操作）。然后将结构体按照尾的大小进行排序。

接下来就进行动态的区间查询，扩展区间右端点。将那串数一次读进，来更新线段树，如果当前点只读进来一次，更新该点，若是不是一次，则需将之前的那些点置为零，并更新该点。因为对于一段区间相异数的和，有的数出现不只一次，那么只要这个数在该区间中最后一次的出现。

AC代码：

///因为需要求区间内互异值的和，对于一个固定的区间的话，自然只需要对于相同的值只留一个，其他置零即可。
//但是对于动态的查询区间，保留的那个值的位置相对关键。
//通过对查询的区间进行排序可以讲区间有序的排列（以区间的右端点递增排序）。
//如果我们对于a[i]，把之前出现过的a[i]都置零，这样此时对于已生成的区间[1, i]，
//我们查询区间和[k, i]的时候（因为区间是按照右端点有序查询的），必然对于任意值p，都是先包含离i最近的那个p，才会包含前面的p，
//而前面的p已经被置零，故不会加入计算。而离i最近的p又会加入计算，不会影响结果。
//所以这样边生成区间[1, i]，边对于[k, i]区间查询。对于之前出现过的a[i]置零，便可以达到查询效果。
//当然最好输出的结果是按照题目要求的查询顺序输出的，这里采用了保存在sam数组中。
//不过这里还有一点就是，如何对于之前的a[i]置零，此处采用了map，map里保存了最右端的a[i]的脚标，这样不断更新即可。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<vector>
#define ll long long
using namespace std;
int t,n,m;
const int INF=3e4+5;
const int Max=1e5+5;
struct node{
	int id;
	int from;
	int to;
}g[Max];
ll sam[Max];
struct Node{
	int right;
	int left;
	ll sum;
}f[4*INF];
ll a[INF];
bool cmp(node q1,node q2)
{
	return q1.to <q2.to ;
}
map<int ,int>p;
void built(int ans,int l,int r)//建树 
{
	f[ans].left =l;f[ans].right =r;
	f[ans].sum =0;
	if(l==r)return ;
	int mid=(l+r)/2;
	built(ans<<1,l,mid);
	built(ans<<1|1,mid+1,r);
}
void update(int ans,int l,int r,ll x)
{
	if(f[ans].left ==l&&f[ans].right ==r)
	{
		f[ans].sum =x;return;
	}
	int mid=(f[ans].left +f[ans].right )/2;
	if(r<=mid){
		update(ans<<1,l,r,x);
	}
	else if(l>mid)update(ans<<1|1,l,r,x);
	else {
		update(ans<<1,l,mid,x);
		update(ans<<1|1,mid+1,r,x);
	}
	f[ans].sum =f[ans<<1].sum +f[ans<<1|1].sum ;//更新 
}
ll getsum(int ans,int l,int r)
{
	if(f[ans].left ==l&&f[ans].right ==r)
	{
		return f[ans].sum ;
	}
	int mid=(f[ans].left +f[ans].right )/2;
	if(r<=mid)
	{
		return getsum(ans<<1,l,r);
	}
	else if(l>mid)
	{
		return getsum(ans<<1|1,l,r);
	}
	else {
		return getsum(ans<<1,l,mid)+getsum(ans<<1|1,mid+1,r);
	}
}
int main()
{
	cin>>t;
	while(t--)
	{
		scanf("%d",&n);
		p.clear() ;
        int i,j,k;
	    for(i=1;i<=n;i++)
		{
		    scanf("%lld",&a[i] ); 	
		}
		scanf("%d",&m);
		for(i=1;i<=m;i++)
		{
			scanf("%d%d",&g[i].from ,&g[i].to );
			g[i].id =i;
		}
		sort(g+1,g+m+1,cmp);
		built(1,1,n);
		for(i=1,k=1;i<=n;i++)//动态的区间查询 
		{
			j=p[a[i]];
			if(j==0)//说明这个数第一次读入 
			{
				update(1,i,i,a[i]);
				p[a[i]]=i;//用来标记 
			}
			else {
				update(1,j,j,0);//将之前的置零 
				update(1,i,i,a[i]);//当前的赋值为a[i] 
				p[a[i]]=i;
			}
			for(;k<=m&&g[k].to ==i;k++)//结构体中已排好序 
			{
				sam[g[k].id ]=getsum(1,g[k].from ,g[k].to );//将每次查询的结果放在一个数组里 
			}
		}
		for(i=1;i<=m;i++)
		{
			printf("%lld\n",sam[i]);
		}
	}
	return 0;
}