zoj 2243 Binary Search Heap Construction （笛卡尔树）

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1243

　　这时一道笛卡尔树的题目。

　　刚开始，想都没想就手打了一棵Treap，也没有计算最坏情况下要操作多少次，于是就一直改指针什么的，并一直TLE。后来，只好找题解来解释一下我TLE的原因了。直接就看到一个博客，博主也是跟我一样，刚开始的时候用了Treap，结果TLE了。然后，我就看到了一个新名词——笛卡尔树(Cartesian Tree)。我立即维基了一下笛卡尔树的定义，发现原来笛卡尔树的构造十分简单。

　　笛卡尔树，一种特殊的Treap，采用离线插入。当结点权值被固定的时候，Treap没有了随机化，将有变得相当不平衡的状态。这时，如果用Cartesiant Tree算法，可以保证将复杂度限制在O(nlogn)中。首先，将要插入的结点按找key值来排序，这个操作的复杂度视排序方法而定。然后，按顺序插入到树中。注意，这里插入的方法有点不一样，不是用Treap的插入方法，如果用那种方法，算法将退化到O(n^2)。笛卡尔树的插入，是由上一插入的结点开始查找的（鉴于笛卡尔树的特殊性，结点需要指向父节点的指针）。从上一插入的结点开始，向祖先的方向查找到第一个权值(fix)比插入的结点大的结点（这里用的是最大堆），然后就将该结点的右子树（就是刚刚找上来的那边）作为待插入的结点的左子树，然后该节点的右儿子就由新插入的结点来代替。back指针指向这个新插入的结点。这里的复杂度是O(n)。

　　为什么这样的复杂度只有O(n)？

　　因为在最右边的直链的长度最多为n，而且如果插入的结点的fix值比它大，他们将会被转移到左子树，于是搜索的次数不超过n，插入的次数为n，加起来就是O(2*n)，也就是O(n)。然后整体的复杂度就由排序的方式来决定了！

 

代码如下：

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

using namespace std;
typedef pair<string, int> psi;
typedef vector<psi> vpsi;

struct Node {
    Node *child[2], *parent;
    string key;
       int fix;
    Node(string _key, int _fix) {
        child[0] = child[1] = parent = NULL;
        key = _key;
        fix = _fix;
    }
};

struct Cartesian {
    Node *root, *back;
    Cartesian() {
        root = back = NULL;
    }

    void rotate(Node *rt, bool left){
        bool right = !left;
        Node *p = rt->child[right];

        p->parent = rt->parent;
        if (p->child[left]) p->child[left]->parent = rt;
        rt->child[right] = p->child[left];
        rt->parent = p-> child[left];
        p->child[left] = rt;
    }

    void pushBack(Node *x) {
        Node *p = back;

        while (p && p->fix < x->fix) p = p->parent;
//printf("insert at %d\n", p);
        if (p) {
            if (p->child[false]) p->child[false]->parent = x;
            x->child[true] = p->child[false];
            x->parent = p;
            p->child[false] = x;
        } else {
            if (root) root->parent = x;
            x->child[true] = root;
            root = x;
        }
        back = x;
    }

    void print(Node *T) {
        if (!T) return ;
        putchar('(');
        print(T->child[true]);
        printf("%s/%d", T->key.c_str(), T->fix);
        print(T->child[false]);
        putchar(')');
    }
}cart;

void deal(int n) {
    cart = Cartesian();

    char buf[100];
    vpsi tmp;

    while (n--){
        scanf("%s", buf);

        int p = 0, key;

        while (buf[p] != '/') p++;
        buf[p] = 0;
        sscanf(&buf[p + 1], "%d", &key);
        tmp.push_back(make_pair(buf, key));
    }
    sort(tmp.begin(), tmp.end());

    int size = tmp.size();

    for (int i = 0; i < size; i++) {
        Node *temp = new Node(tmp[i].first, tmp[i].second);

//printf("cur %s  %d\n", tmp[i].first.c_str(), tmp[i].second);
//puts("pass");
//printf("back  %d\n", cart.back);
        cart.pushBack(temp);
//cart.print(cart.root);
//puts("");
    }
    cart.print(cart.root);
    puts("");
}

int main(){
    int n;

//freopen("in", "r", stdin);
    while (~scanf("%d", &n) && n){
        deal(n);
    }

    return 0;
}

 

——written by Lyon