poj 2418 Hardwood Species

原题链接：http://poj.org/problem?id=2418

简单题。。

平衡树，写了个模板。。动态分配内存确实很慢。。。

#include<algorithm>
#include<iostream>
#include<string>
#include<cstdlib>
#include<cstring>
#include<cstdio>
using std::string;
template<typename T>
class sb_tree{
private:
    struct Node{
        T data;
        int s, c;
        Node *ch[2];
        Node(const T&d) :s(1), c(1), data(d){}
        Node() :s(0), c(0){ ch[0] = ch[1] = this; }
        inline void push_up(){
            s = ch[0]->s + ch[1]->s + c;
        }
        inline int cmp(const T&v) const{
            return v == data ? -1 : v > data;
        }
    }*null, *root;
    inline void rotate(Node* &x, int d){
        Node *k = x->ch[!d];
        x->ch[!d] = k->ch[d];
        k->ch[d] = x;
        k->s = x->s;
        x->push_up();
        x = k;
    }
    inline void Maintain(Node* &x, int d){
        if (x->ch[d] == null) return;
        if (x->ch[d]->ch[d]->s > x->ch[!d]->s){
            rotate(x, !d);
        } else if (x->ch[d]->ch[!d]->s > x->ch[!d]->s){
            rotate(x->ch[d], d), rotate(x, !d);
        } else {
            return;
        }
        Maintain(x, 0), Maintain(x, 1);
    }
    inline void insert(Node *&x, const T&data){
        if (!x->s){
            x = new Node(data);
            x->ch[0] = x->ch[1] = null;
        } else{
            x->s++;
            int d = x->cmp(data);
            if (-1 == d){
                x->c++;
                return;
            }
            insert(x->ch[d], data);
            x->push_up();
            Maintain(x, d);
        }
    }
    inline void del(Node *&x, const T&data){
        if (!x->s) return ;
        x->s--;
        int d = x->cmp(data);
        if (-1 == d){
            if (x->c > 1){
                x->c--;
                return;
            } else if (!x->ch[0]->s || !x->ch[1]->s){
                x = x->ch[0]->s ? x->ch[0] : x->ch[1];
            } else {
                Node *ret = x->ch[1];
                for (; ret->ch[0]->s; ret = ret->ch[0]);
                del(x->ch[1], x->data = ret->data);
            }
        } else {
            del(x->ch[d], data);
        }
        if (x->s) x->push_up();
    }
    void clear(Node* &x){
        if (x->s) clear(x->ch[0]), clear(x->ch[1]), delete x;
    }
public:
    sb_tree() :null(new Node), root(null){}
    ~sb_tree(){ clear(root), delete null; }
    inline void clear(){ clear(root), root = null; }
    inline void insert(const T&data){
        insert(root, data);
    }
    inline void del(const T&data){
        del(root, data);
    }
    inline bool find(const T&data){
        Node *x = root;
        while (x->s && x->data != data) x = x->ch[x->data < data];
        return x->s;
    }
    inline const T&kth(int k){
        Node *x = root;
        for (int t = 0; x != null;){
            t = x->ch[0]->s;
            if (k <= t) x = x->ch[0];
            else if (t + 1 <= k && k <= t + x->c) break;
            else k -= t + x->c, x = x->ch[1];
        }
        return x->data;
    }
    inline int rank(const T&data){
        Node *x = root;
        int t = 0, cur = 0;
        for (cur = 0; x != null;){
            t = x->ch[0]->s;
            if (data == x->data) break;
            else if (data < x->data) x = x->ch[0];
            else cur += t + x->c, x = x->ch[1];
        }
        return cur + t + 1;
    }
    inline const T&operator[](int k){
        return kth(k);
    }
    inline const T&preorder(const T&data){
        Node *x = root, *y = 0;
        while (x->s){
            if (x->data < data) y = x, x = x->ch[1];
            else x = x->ch[0];
        }
        return y ? y->data : data;
    }
    inline const T&successor(const T&data){
        Node *x = root, *y = 0;
        while (x->s){
            if (data < x->data) y = x, x = x->ch[0];
            else x = x->ch[1];
        }
        return y ? y->data : data;
    }
    inline int size(){ return root->s; }
    inline void query(Node *x, int cnt){
        if (x != null){
            query(x->ch[0], cnt);
            string str = x->data;
            printf("%s %.4lf
", str.c_str(), (double)x->c * 100 / cnt);
            query(x->ch[1], cnt);
        }
    }
    inline void query(){
        int cnt = size();
        query(root, cnt);
    }
};
int main(){
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w+", stdout);
#endif
    char buf[100];
    sb_tree<string> ans;
    while (gets(buf)) ans.insert(buf);
    ans.query();
    return 0;
}

如果不想写平衡树，就写个快排吧。。注意用c提交：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef char State[33];
State st[1000010];
int cmp(const char* src, const char *_src){
    return strcmp((char *)src, (char *)_src);
}
int main(){
    State ret, buf;
    int i, k, cnt = 0;
    while (gets(ret)) strcpy(st[cnt++], ret);
    qsort(st, cnt, sizeof(st[0]), cmp);
    i = 0;
    while (i < cnt){
        strcpy(buf, st[i]), k = 0;
        for (; 0 == strcmp(buf, st[i]); i++) k++;
        printf("%s %.4lf
", buf, (double)k * 100 / cnt);
    }
    return 0;
}