poj 2104 Kth Number(可持久化线段树)

http://poj.org/problem?id=2104

　　这是我第二次写这题了，原因只前两天看了可持久化数据结构的论文，看到线段树用可持久化的方式来写可以完成这题，于是在我构思好以后就一气呵成的把这题打了出来。一打出来就顺利通过了编译，不过刚开始的时候忘记将新建的结点的两个指针都赋值，所以稍稍debug了一下这个小问题。交上去以后RE了几次，原因是我的hash写烂了。在我改过来以后又变成TLE了，于是我就改成了模拟分配内存。。。。。几经周折，终于AC了！

　　这个题感觉如果是用可持久化来写，思路比较容易理清，不用像划分树复杂的位置运算，也不用像树套树那样动则200行代码。

代码如下：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cassert>

using namespace std;

const int maxn = 100005;
const int HASH = 0x55555555;
const int hashSize = 400009;

int hash[hashSize], hashPos[hashSize];

void initHash() {
    memset(hashPos, -1, sizeof(hashPos));
}

void insHash(int x, int pos) {
    int p = (x ^ HASH) % hashSize;

    if (p < 0) p += hashSize;
    while (hash[p] != x && ~hashPos[p]) {
        p = (p + 1) % hashSize;
    }

    hash[p] = x;
    hashPos[p] = pos;
}

int getPos(int x) {
    int p = (x ^ HASH) % hashSize;

    if (p < 0) p += hashSize;
    while (hash[p] != x && ~hashPos[p]) {
        p = (p + 1) % hashSize;
    }

    return hashPos[p];
}

int buf[maxn], num[maxn];
int cntNode;
struct Node {
    int cnt;
//    Node *left, *right;
    int left, right;

    Node(int _cnt = 0) {
        cnt = _cnt;
//        left = right = NULL;
        left = right = 0;
    }
//} *Root[maxn], *Null;
} node[maxn << 5];
int Root[maxn];


void input(int n) {
    memset(Root, 0, sizeof(Root));
    cntNode = 0;
//    Null = new Node();
    node[0] = Node();
    for (int i = 1; i <= n; i++) {
        scanf("%d", &buf[i]);
        num[i] = buf[i];
    }
    sort(num + 1, num + n + 1);

    initHash();
    for (int i = 1; i <= n; i++) {
        insHash(num[i], i);
    }
}

//void up(Node *rt) {
void up(int rt) {
//    rt->cnt = rt->left->cnt + rt->right->cnt;
    node[rt].cnt = node[node[rt].left].cnt + node[node[rt].right].cnt;
}

//#define lson l, m, rt->left
//#define rson m + 1, r, rt->right
#define lson l, m, node[rt].left
#define rson m + 1, r, node[rt].right

//void build(int l, int r, Node *&rt) {
void build(int l, int r, int &rt) {
//    rt = new Node();
    rt = ++cntNode;
    node[rt] = Node();
    if (l == r) {
//        rt->left = rt->right = Null;
        return ;
    }
    int m = (l + r) >> 1;

    build(lson);
    build(rson);
    up(rt);
}

//void update(int x, int l, int r, Node *rt, Node *&newRt) {
void update(int x, int l, int r, int rt, int &newRt) {
    if (l == r) {
//        newRt = new Node(rt->cnt + 1);
        newRt = ++cntNode;
        node[newRt] = Node(node[rt].cnt + 1);
//        newRt->left =newRt->right = Null;

        return ;
    }
    int m = (l + r) >> 1;

//    newRt = new Node();
    newRt = ++cntNode;
    node[newRt] = Node();
//    puts("???");
    if (x <= m) {
//        update(x, lson, newRt->left);
//        newRt->right = rt->right;
        update(x, lson, node[newRt].left);
        node[newRt].right = node[rt].right;
    } else {
//        update(x, rson, newRt->right);
//        newRt->left = rt->left;
        update(x, rson, node[newRt].right);
        node[newRt].left = node[rt].left;
    }
    up(newRt);
}

//#define l2son l, m, rt1->left, rt2->left
//#define r2son m + 1, r, rt1->right, rt2->right
#define l2son l, m, node[rt1].left, node[rt2].left
#define r2son m + 1, r, node[rt1].right, node[rt2].right

//int query(int k, int l, int r, Node *rt1, Node *rt2) {
int query(int k, int l, int r, int rt1, int rt2) {
    if (l == r) {
        return num[l];
    }
    int m = (l + r) >> 1;
//    int cnt = rt2->left->cnt - rt1->left->cnt;
    int cnt = node[node[rt2].left].cnt - node[node[rt1].left].cnt;

//    assert(0 <= cnt && cnt <= r - l + 1);
    if (k <= cnt) {
        return query(k, l2son);
    } else {
        return query(k - cnt, r2son);
    }
}

int segK(int l, int r, int k, int n) {
    return query(k, 1, n, Root[l - 1], Root[r]);
}
/*
void printTree(Node *rt) {
    if (!rt) return ;
    putchar('(');
    printTree(rt->left);
    printf("%d", rt->cnt);
    printTree(rt->right);
    putchar(')');
}
*/
int main() {
    int n, m;

//    freopen("in", "r", stdin);
    while (~scanf("%d%d", &n, &m)) {
        input(n);
        build(1, n, Root[0]);
        for (int i = 1; i <= n; i++) {
            update(getPos(buf[i]), 1, n, Root[i - 1], Root[i]);
//            printTree(Root[i]);
//            puts("~~~");
        }
        while (m--) {
            int l, r, k;

            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", segK(l, r, k, n));
        }
    }

    return 0;
}

——written by Lyon