uva live 5031 Graph and Queries（Treap x 并查集）

题意：
。。。
同样收录在 HDU 3726，不过hdu貌似有时候 re 会报 wa，不方便调错。。
思路：
教科书题。。
用来练 Treap 模板很合适

尝试写了几发GC， 用stack来装指针。。发现效率都不是很高。。还很耗内存。。于是放弃了。。

// 纯动态
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <climits>
#include <set>
#include <queue>
#include <map>
#include <cmath>
#include <cassert>
#include <stack>
#include <stdexcept>
using namespace std;
#define rep(i, s, t) for(int (i)=(s);(i)<=(t);++(i))
const int N = 20000 + 5;
typedef long long LL;

struct Node {
    Node* ch[2];
    int fix, key, cnt, sz;

    inline void update() {
        sz = cnt + ch[0]->sz + ch[1]->sz;
    }

    inline bool lt(int other) const {
        return key < other;
    }
} *nil;

Node* allocate_node(int key) {
    Node* nd = new Node();
    nd->ch[0] = nd->ch[1] = nil;
    nd->sz = nd->cnt = 1;
    nd->key = key;
    nd->fix = rand();
    return nd;
}

void free_node(Node* rt) {
    if ( rt->ch[0] != nil ) free_node(rt->ch[0]);
    if ( rt->ch[1] != nil ) free_node(rt->ch[1]);
    delete rt;
}

// d: 0 - right rotate, 1 - left rotate
void Rot(Node* &rt, int d) {
    Node *t = rt->ch[d];
    rt->ch[d] = t->ch[1^d];
    t->ch[1^d] = rt;
    rt->update();
    t->update();
    rt = t;
}

void Insert(Node* &rt, int key) {
    if ( rt != nil ) {
        if ( key == rt->key ) {
            ++ rt->cnt;
        } else {
            int d = rt->lt(key); // insert into ch[d]
            Insert(rt->ch[d], key);
            if ( rt->ch[d]->fix < rt->fix ) Rot(rt, d);
        }

    } else {
        rt = allocate_node(key);
    }
    rt->update();
}

void Erase(Node* &rt, int key) {
    if ( rt != nil ) {
        if ( rt->key == key ) {
            if ( rt->cnt > 1 ) {
                -- rt->cnt;
            } else {
                if ( rt->ch[0] == nil && rt->ch[1] == nil  ) {
                    rt = nil; return;
                } else {
                    int d = rt->ch[0]->fix > rt->ch[1]->fix;
                    Rot(rt, d);
                    Erase(rt->ch[1^d], key);
                }
            }
        } else {
            int d = rt->lt(key);
            Erase(rt->ch[d], key);
        }
        rt->update();
    } else {
        //cout << "not found" << endl;
    }
}

int GetKth(const Node* rt, int k) {
    if ( k <= rt->ch[0]->sz )
        return GetKth(rt->ch[0], k);
    k -= rt->ch[0]->sz + rt->cnt;
    if ( k <= 0 )
        return rt->key;
    if ( k <= rt->ch[1]->sz )
        return GetKth(rt->ch[1], k);
    else {
        //throw runtime_error("k is larger than size");
        while (1);
    }
}

void MergeTo(Node* src, Node* &dst) {
    if ( src == nil ) return;
    queue<Node*> q;
    q.push(src);
    while ( !q.empty() ) {
        Node* u = q.front(); q.pop();
        for(int i = 0; i < u->cnt; ++ i) Insert(dst, u->key);
        if ( u->ch[0] != nil ) q.push(u->ch[0]);
        if ( u->ch[1] != nil ) q.push(u->ch[1]);
    }
    free_node(src);
}

void treap_global_init() {
    nil = new Node();
    memset(nil, 0, sizeof(Node));
    nil->fix = INT_MAX;
}

const int MaxV = 2e4 + 5, MaxE = 6e4 + 5;

struct Op {
    char type;
    int x, y;
} ops[500005];

int weight[MaxV], can[MaxE], edges[MaxE][2];
Node *tr[MaxV];

namespace UF {
    int pa[MaxV];

    void init(int n) {
        rep(i, 0, n-1) pa[i] = i;
    }

    int find(int x) {
        return x == pa[x] ? x : pa[x] = find(pa[x]);
    }

    void Union(int x, int y, int ctl = 0) {
        int px = find(x), py = find(y);
        if ( px != py ) {
            if ( tr[px]->sz > tr[py]->sz ) {
                if ( ctl )  {
                    MergeTo(tr[py], tr[px]);
                }
                pa[py] = px;
            } else {
                if ( ctl ) {
                    MergeTo(tr[px], tr[py]);
                }
                pa[px] = py;
            }
        }
    }
};

int main() {
#ifdef _LOCA_ENV_
    freopen("input.in", "r", stdin);
#endif // _LOCA_ENV
    /// treap init ///
    treap_global_init();
    /// start here ///
    int n, m, cas = 0;
    while ( scanf("%d%d", &n, &m) != EOF && n ) {
        rep(i, 0, n-1) scanf("%d", weight + i);
        rep(i, 0, m-1) {
            can[i] = 1;
            scanf("%d%d", &edges[i][0], &edges[i][1]);
            -- edges[i][0], -- edges[i][1];
        }
        int onm = 0;
        while ( 1 ) {
            char op;
            int x, y, z;
            for (op = getchar(); op == ' ' || op == '\n'; op = getchar());
            ops[onm].type = op;
            if ( op == 'D' ) {
                scanf("%d", &x);
                -- x;
                ops[onm].x = x;
                can[x] = 0;
            } else if ( op == 'Q' ) {
                scanf("%d%d", &x, &y);
                -- x;
                ops[onm].x = x;
                ops[onm].y = y;
            } else if ( op == 'C' ) {
                scanf("%d%d", &x, &y);
                -- x;
                ops[onm].x = x;
                ops[onm].y = weight[x];
                weight[x] = y;
            } else
                break;
            ++ onm;
        }

        UF::init(n);
        rep(i, 0, n-1) {
            tr[i] = nil;
            Insert(tr[i], weight[i]);
        }
        rep(i, 0, m-1) if ( can[i] ) UF::Union(edges[i][0], edges[i][1], 1);

        double tot = 0, qnm = 0;;
        for (int o = onm - 1; o >= 0; -- o) {
            int tmp = -1;
            if ( ops[o].type == 'Q' ) {
                int x = UF::find(ops[o].x);
                //cout << " root " << x  << " , "<< tr[x].size() << endl;
                if ( ops[o].y >= 1 && ops[o].y <= tr[x]->sz ) {
                    tmp = GetKth(tr[x], tr[x]->sz + 1 - ops[o].y);
                    tot += tmp;
                }
                qnm += 1;
            } else if ( ops[o].type == 'C' ) {
                int x = UF::find(ops[o].x);
                Erase(tr[x], weight[ops[o].x]);
                Insert(tr[x], ops[o].y);
                weight[ops[o].x] = ops[o].y;
            } else if ( ops[o].type == 'D' ) {
                int u = edges[ops[o].x][0], v = edges[ops[o].x][1];
                UF::Union(u, v, 1);
            }
        }
        double ans = tot / qnm;
        printf("Case %d: %.6f\n", ++ cas, ans);

        rep(i, 0, n-1) {
            int x = UF::find(i);
            if ( tr[x] != nil ) {
                free_node(tr[x]);
                tr[x] = nil;
            }
        }
    }
    return 0;
}