Codeforces 296C

写了个简单的AVL，只插入不删除。

当然Tutorial里给出的解法更简单

// Codeforces 296C
#include<iostream>
#include<cstdio>
#include<memory.h>
using namespace std;

class AVL{
private:
    struct AVLNode{
        int begin;
        int end;
        int height;
        AVLNode* left;
        AVLNode* right;

        AVLNode(int b, int e, int h = 0, AVLNode* l = NULL, AVLNode* r = NULL) :
            begin(b), end(e), height(h), left(l), right(r) {}
        AVLNode() : left(NULL), right(NULL) {}
    };

    AVLNode* root;
    int* lencnt;
    long long max;

    int Height(AVLNode* root){
        if (root == NULL) return -1;
        else return root->height;
    }

    AVLNode* LL(AVLNode* root){
        AVLNode* tmp = root->left;
        root->left = tmp->right;
        tmp->right = root;
        root->height = ((Height(root->left) > Height(root->right)) ? 
            Height(root->left) : Height(root->right)) + 1;
        tmp->height = ((Height(tmp->left) > Height(tmp->right)) ?
            Height(tmp->left) : Height(tmp->right)) + 1;
        return tmp;
    }
    AVLNode* LR(AVLNode* root){
        root->left = RR(root->left);
        root = LL(root);
        return root;
    }
    AVLNode* RL(AVLNode* root){
        root->right = LL(root->right);
        root = RR(root);
        return root;
    }
    AVLNode* RR(AVLNode* root){
        AVLNode* tmp = root->right;
        root->right = tmp->left;
        tmp->left = root;
        root->height = ((Height(root->left) > Height(root->right)) ?
            Height(root->left) : Height(root->right)) + 1;
        tmp->height = ((Height(tmp->left) > Height(tmp->right)) ?
            Height(tmp->left) : Height(tmp->right)) + 1;
        return tmp;
    }

    AVLNode* insert(AVLNode* root, int b, int e){
        if (root == NULL) return new AVLNode(b, e);

        if (e <= root->begin) root->left = insert(root->left, b, e);
        else root->right = insert(root->right, b, e);

        if (Height(root->left) - Height(root->right) >= 2){
            if (Height(root->left->left) > Height(root->left->right))
                root = LL(root);
            else root = LR(root);
        }
        else if (Height(root->right) - Height(root->left) >= 2){
            if (Height(root->right->right) > Height(root->right->left))
                root = RR(root);
            else root = RL(root);
        }

        root->height = ((Height(root->left) > Height(root->right)) ?
            Height(root->left) : Height(root->right)) + 1;

        return root;
    }

    void remove(AVLNode* root){
        if (root == NULL) return;
        remove(root->left);
        remove(root->right);
        delete root;
    }

public:
    AVL(int len){
        root = new AVLNode(0, len);
        lencnt = new int[len + 1];
        memset(lencnt, 0, (len + 1) * sizeof(int));
        lencnt[len] = 1;
        max = len;
    }

    ~AVL(){
        delete[] lencnt;
        remove(root);
    }

    void split(int pos){
        // Find the segment containing this position
        AVLNode* tmp = root;
        while (true){
            if (pos > tmp->end) tmp = tmp->right;
            else if (pos < tmp->begin) tmp = tmp->left;
            else break;
        }

        // Update the segment counts
        lencnt[tmp->end - tmp->begin]--;
        lencnt[pos - tmp->begin]++;
        lencnt[tmp->end - pos]++;
        if (lencnt[max] == 0) while (lencnt[max] == 0) max--;

        int e = tmp->end;
        tmp->end = pos;
        root = insert(root, pos, e);
    }

    long long getMax() const{
        return max;
    }

};

int main(){
    int w, h, n, i, k;
    cin >> w >> h >> n;
    AVL row(w);
    AVL col(h);
    char dir;
    int pos;

    for (k = 1; k <= n; k++){
        cin >> dir;
        if (dir == 'H'){
            cin >> pos;
            col.split(pos);
        }
        else {
            cin >> pos;
            row.split(pos);
        }

        cout << row.getMax() * col.getMax() << endl;
    }

    return 0;
}