HDU 3333 & 3874 (线段树+离线询问)

两个题目都是求区间之内，不重复的数字之和，3333需要离散化处理.................

调试了一下午........说多了都是泪...........

 

#include <iostream>

#include <algorithm>

#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <string>

#include <map>

#include <queue>

#include <climits>//形如INT_MAX一类的

#define MAX 51111

#define INF 0x7FFFFFFF

#define L(x) x<<1

#define R(x) x<<1|1

//#pragma comment(linker, "/STACK:36777216") ///传说中的外挂

using namespace std;



inline void RD(int &ret) {

    char c;

    do {

        c = getchar();

    } while(c < '0' || c > '9') ;

    ret = c - '0';

    while((c=getchar()) >= '0' && c <= '9')

        ret = ret * 10 + ( c - '0' );

}



inline void OT(int a) {

    if(a >= 10)OT(a / 10) ;

    putchar(a % 10 + '0') ;

}



struct node {

    int l,r,mid,cover;

    __int64 sum;

} tree[MAX*4];



int n,m;

int a[MAX],va[MAX],pos[MAX],tmp[MAX];

__int64 ans[111111 * 2];



struct Node {

    int l,r;

    int id;

} qes[111111 * 2];



void init() {

    memset(va,0,sizeof(va));

}

int search(int l,int r,int x) {

    int mid;

    while(l <= r) {

        mid = (l+r) >> 1;

        if(pos[mid] == x) return mid;

        else if(pos[mid] > x) r = mid -1;

        else l = mid + 1;

    }

}



void up(int num) {

    tree[num].sum = tree[L(num)].sum + tree[R(num)].sum;

}



void build(int l,int r,int num) {

    tree[num].l = l;

    tree[num].r = r;

    tree[num].mid = (l+r) >> 1;

    tree[num].cover = 0;

    tree[num].sum = 0;

    if(l == r) {

        tree[num].sum = va[l];

        return ;

    }

    build(l,tree[num].mid,L(num));

    build(tree[num].mid + 1,r,R(num));

    up(num);

}



void update(int l,int x,int color) {

    if(tree[x].l == tree[x].r) {

        tree[x].sum += color;

        return ;

    }

    if(l > tree[x].mid) update(l,R(x),color);

    else update(l,L(x),color);

    up(x);

}



__int64 query(int l,int r,int num) {

    if(l == tree[num].l && tree[num].r == r) {

        return tree[num].sum;

    }

    if(r <= tree[num].mid) {

        return query(l,r,L(num));

    } else if(l > tree[num].mid) {

        return query(l,r,R(num));

    } else {

        return query(l,tree[num].mid,L(num)) + query(tree[num].mid+1,r,R(num));

    }

}





bool cmp(const Node &a,const Node &b) {

    if(a.r == b.r) return a.l < b.l;

    return a.r < b.r;

}



bool cmp2(const int &a, const int &b) {

    return a < b;

}

int main() {

    int T;

    cin >> T;

    while(T --) {

        init();

        RD(n);

        int t = 1;

        for(int i=1; i<=n; i++) {

            RD(a[i]);

            tmp[i] = a[i];

        }

        sort(tmp+1,tmp+1+n,cmp2);

        pos[1] = tmp[1];

        for(int i=2; i<=n; i++) {

            if(tmp[i] != tmp[i-1]) {

                pos[++t] = tmp[i];

            }

        }

        build(1,n,1);

        RD(m);

        for(int i=1; i<=m; i++) {

            RD(qes[i].l);

            RD(qes[i].r);

            qes[i].id = i;

        }

        sort(qes+1,qes+1+m,cmp);

        int order = 1;

        for(int i=1; i<=m; i++) {

            while(qes[i].r >= order) {

                int id = search(1,t,a[order]);

                int ps = va[id];

                if( ps != 0) update(ps,1,-a[order]);

                va[id] = order;

                update(va[id],1,a[order]);

                order ++;

            }

            ans[qes[i].id] = query(qes[i].l,qes[i].r,1);

        }

        for(int i=1; i<=m; i++) {

            printf("%I64d\n",ans[i]);

        }

    }

    return 0;

}