HDU3726---Graph and Queries 离线处理+Treap

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3726

题意：n个点m条边的一张无向图，每个点有一个权值， 有3中操作。

D X 删除第X条边

Q X K 计算与X点相连所有点中第k大的权值

C X V把X的权值改为 V

输出 Q次询问的平均值

大白上的例题， 离线处理，把所有操作 反过来处理，，这样删边变成了 加边，，瞬间好处理多了。。细节也有很多。

#include <set>
#include <map>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int maxn = 2e4+10;
int n, m, val[maxn];
int pa[maxn];
void init()
{
    for (int i = 0; i <= n; i++)
    {
        pa[i] = i;
    }
}
int find(int x)
{
    return pa[x] = (pa[x] == x ? x : find(pa[x]));
}
struct Node
{
    Node* ch[2];
    int key, r, siz;
    Node (int x)
    {
        key = x;
        siz = 1;
        ch[0] = ch[1] = NULL;
        r = rand();
    }
    bool operator < (const Node &rhs)const
    {
        return r < rhs.r;
    }
    int cmp(int x)
    {
        if (x == key)
            return -1;
        return x < key ? 0 : 1;
    }
    void maintain()
    {
        siz = 1;
        if (ch[0] != NULL)
            siz += ch[0] -> siz;
        if (ch[1] != NULL)
            siz += ch[1] -> siz;
    }
};
void rotate(Node* &root, int d)
{
    Node* tmp = root -> ch[d^1];
    root -> ch[d^1] = tmp -> ch[d];
    tmp -> ch[d] = root;
    root -> maintain();
    tmp -> maintain();
    root = tmp;
}
void insert(Node* &root, int x)
{
    if (root == NULL)
        root = new Node (x);
    else
    {
        int d = x < root -> key ? 0 : 1;
        insert (root ->ch[d], x);
        if (root -> ch[d] -> r > root -> r)
            rotate(root, d^1);

    }
    root -> maintain();
}
void dele(Node* &root, int x)
{
    int d = root -> cmp(x);
    if (d == -1)
    {
        Node* tmp = root;
        if (root -> ch[0] != NULL && root -> ch[1] != NULL)
        {
            int d1 = (root -> ch[0] -> r > root -> ch[1] -> r ? 0 : 1);
            rotate(root, d1^1);
            dele(root -> ch[d1^1], x);
        }
        else
        {
            if (root -> ch[0] == NULL)
                root = root -> ch[1];
            else
                root = root -> ch[0];
            delete tmp;
        }
    }
    else
        dele(root->ch[d], x);
    if (root != NULL)
        root -> maintain();
}
int Get_kth(Node* root, int k)
{
    if (root == NULL || k <= 0 || root -> siz < k)
        return 0;
    int s = root -> ch[1] == NULL ? 0 : root -> ch[1] -> siz;
    if (s + 1 == k)
        return root -> key;
    if (s + 1 > k)
        return Get_kth(root -> ch[1], k);
    else
        return Get_kth(root -> ch[0], k-s-1);

}
Node* root[maxn];
void merge_tree(Node* &src, Node* &fa)
{
    if (src -> ch[0] != NULL)
        merge_tree(src -> ch[0], fa);
    if (src -> ch[1] != NULL)
        merge_tree(src -> ch[1], fa);
    insert(fa, src -> key);
    delete src;
    src = NULL;
}
void remove_tree(Node* &root)
{
    if (root -> ch[0] != NULL)
        remove_tree(root -> ch[0]);
    if (root -> ch[1] != NULL)
        remove_tree(root -> ch[1]);
    delete root;
    root = NULL;
}
struct
{
    int x, y;
    bool is_del;
} e[3 * maxn];
struct
{
    int type, x, p;
} Q[maxn*25];
void add_edge(int idx)
{
    int fx = find(e[idx].x);
    int fy = find(e[idx].y);
    if (fx != fy)
    {
        if (root[fx] -> siz > root[fy] -> siz)
        {
            pa[fy] = fx;
            merge_tree(root[fy], root[fx]);
        }
        else
        {
            pa[fx] = fy;
            merge_tree(root[fx], root[fy]);

        }
    }

}
int main(void)
{
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
#endif
    int cas = 1;
    while (~ scanf ("%d%d",&n, &m))
    {
        if (n == 0 && m == 0)
            break;
        for (int i = 0; i < n; i++)
        {
            scanf ("%d", val + 1 + i);
        }
        for (int i = 1; i <= m; i++)
        {
            scanf ("%d%d", &e[i].x, &e[i].y);
            e[i].is_del = false;
        }
        char op[5];
        int tot = 0;
        while (scanf ("%s",op) && op[0] != 'E')
        {
            if (op[0] == 'D')
            {
                scanf ("%d", &Q[tot].x);
                Q[tot++].type = 0;
                e[Q[tot-1].x].is_del = true;
            }
            if (op[0] == 'Q')
            {
                scanf ("%d%d", &Q[tot].x, &Q[tot].p);
                Q[tot++].type = 1;
            }
            if (op[0] == 'C')
            {
                int v;
                scanf ("%d%d", &Q[tot].x, &v);
                Q[tot].p = val[Q[tot].x];
                val[Q[tot].x] = v;
                Q[tot++].type = 2;
            }
        }
        init();
        for (int i = 0; i < n; i++)
        {
            if (root[i+1] != NULL)
                remove_tree(root[i+1]);
            root[i+1] = new Node (val[i+1]);
        }
        for (int i = 0; i < m; i++)
        {
            if (e[i+1].is_del == false)
                add_edge(i+1);
        }
        ll ans1 = 0, ans2 = 0;
        for (int i = tot - 1; i >= 0; i--)
        {
            if (Q[i].type == 0)
            {
                add_edge(Q[i].x);
            }
            if (Q[i].type == 1)
            {
                ans1 += Get_kth(root[find(Q[i].x)], Q[i].p);
                ans2 ++;
            }
            if (Q[i].type == 2)
            {
               int father = find(Q[i].x);
                dele (root[father], val[Q[i].x]);
                insert (root[father], Q[i].p);
                val[Q[i].x] = Q[i].p;
            }
        }
        printf("Case %d: %.6f
", cas++, 1.0*ans1 / ans2);
    }
    return 0;
}