hdu3333-Turing Tree-（线段树+离散化处理）

Turing Tree

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7323    Accepted Submission(s): 2654

Problem 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

 

翻译：t组测试，给n个数，q个查询，查询第i个数到第j个数之间的不重复的数的和是多少？

解题过程：

首先把所有查询区间记录下来，然后按照区间的右值排序，接着从左到右把每一个数更新到线段树中，并记录它出现的位置。如果一个数已经出现过，那么我们就把他上次出现的位置的值置为0，并更新它出现的位置。因为查询区间是按右值排序的，所以当前区间的左值要么和之前一样要么比之前的要大，因此把过去重复出现的数字置为0不会影响结果。当更新到某个区间的右值时，我们就查询一次该区间的答案，并把答案记录到对应的地方。

#include <iostream>
#include<stdio.h>
#include <algorithm>
#include<string.h>
#include<cstring>
#include<math.h>
#include<map>
#define inf 0x3f3f3f3f
#define ll long long
using namespace std;
const int maxx=300010;
int n,m;

struct node
{
    int l;
    int r;
    int idx;
    ll ans;
};
node q[100005];
int a[maxx];
ll sum[maxx*4];


void update(int pos,int a,int l,int r,int rt)
{
    if(l==r)///拼死只为找到pos的位置，然后把最底层的sum[rt]改为a
    {
        sum[rt]=a;return;
    }
    int mid = (l+r)/2;
    if(pos<=mid) update(pos,a,l,mid,rt*2);
    else update(pos,a,mid+1,r,rt*2+1);
    sum[rt]=sum[rt*2]+sum[rt*2+1];///每次只把一个a[i]累加到sum数组里
}

ll query(int L,int R,int l,int r,int rt)
{
    if(L<=l && r<=R)
        return sum[rt];
    int mid=(r+l)/2;
    ll res=0;
    if(L<=mid)
        res+=query(L,R,l,mid,rt*2);
    if(R>=mid+1)
        res+=query(L,R,mid+1,r,rt*2+1);
    return res;
}

bool cmp1(node p1,node p2)
{
    if(p1.r!=p2.r)
        return p1.r<p2.r;
    else
        return p1.l<p2.l;
}

bool cmp2(node p1,node p2)
{
    return p1.idx<p2.idx;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(q,0,sizeof(q));
        memset(a,0,sizeof(a));
        memset(sum,0,sizeof(sum));
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);

        scanf("%d",&m);
        for(int i=1;i<=m;i++)
            scanf("%d %d",&q[i].l,&q[i].r),q[i].idx=i;
        sort(q+1,q+m+1,cmp1);
        map<int,int>vis;
        int j=1;
        for(int i=1;i<=m;i++)
        {
            while(j<=q[i].r) ///j是一个指针，指示原数组的下标，vis[ a[i] ]则是对应a[j]这个值上次出现的位置
            {
                if( !vis[ a[j] ])///如果a[j]这个值没有出现过
                {
                    update(j,a[j],1,n,1);
                    vis[ a[j] ]=j;
                }
                else
                {
                    update(j,a[j],1,n,1);///先日常把a[j]累加到线段树里
                    update(vis[ a[j] ],0,1,n,1);///然后把上一个a[j]改成0，改动这个影响了哪些sum的值。
                    vis[ a[j] ]=j;///更新a[j]出现的位置。
                }
                j++;
            }
            q[i].ans=query( q[i].l, q[i].r, 1,n,1 );
        }
        sort(q+1,q+m+1,cmp2);
        for(int i=1;i<=m;i++)
            printf("%lld\n",q[i].ans);
    }
    return 0;
}