LA 5031 图询问

题目链接：https://vjudge.net/contest/159527#problem/A

题意：（求一个 图 中的连通分量中的 第 k 大）

一张图，n 个点，m 条边，

有一些操作:

删除 ID 为 x 的边，（从 1 到 m）；

询问 x 所在的连通分量 里面第 k 大的权值；

把结点 X 的权值 改成 V；

求：

所有的询问后，计算平均值；

每个连通分量都是一颗Treap树，加边操作，就是树的合并；

刘汝佳采用的是离线算法，我还是第一次听说，但是还是可以按照题意直接模拟的（我猜，但是很麻烦）；因为在Treap中删边不同于删点；

什么是离线算法呢？

把操作顺序反过来处理，执行完所有 删除边操作，然后建Treap，要是不在同一个连通分量里面（并查集判断），这就涉及到递归合并Treap树了，这里采用了启发式合并；

然后反向操作，遇到 D，就是加边（加边操作同上），

询问，就是在 X 所在连通分量里面，寻找第 k 大；

改权，就是删除这个点，然后从新加点；

#include <bits/stdc++.h>

using namespace std;

struct Node
{
    Node *ch[2];
    int r;  //优先级
    int v;  //值
    int s;  //结点总数

    Node(int v):v(v)
    {
        ch[0] = ch[1] = NULL;
        r = rand();
        s = 1;
    }

    bool operator < (const Node& rhs) const
    {
        return r < rhs.r;
    }

    int cmp(int x) const
    {
        if(x==v) return -1;
        return x < v ? 0 : 1;
    }

    void maintain()
    {
        s = 1;
        if(ch[0]!=NULL) s+=ch[0]->s;
        if(ch[1]!=NULL) s+=ch[1]->s;
    }


};

void rotate(Node* &o,int d)
{
    Node* k = o->ch[d^1];
    o->ch[d^1] = k ->ch[d];
    k->ch[d] = o;
    o->maintain();
    k->maintain();
    o = k;
}

void insert(Node* &o,int x)
{
    if(o==NULL) o = new Node(x);
    else
    {
        int d = (x < o->v? 0 : 1);
        insert(o->ch[d],x);
        if(o->ch[d]->r > o->r)
            rotate(o,d^1);
    }
    o->maintain();
}

void remove(Node* &o,int x)
{
    int d = o->cmp(x);
    if(d==-1)
    {
        Node* u = 0;
        if(o->ch[0]!=NULL&&o->ch[1]!=NULL)
        {
            int d2 = (o->ch[0]->r > o->ch[1]->r ? 1 : 0);
            rotate(o,d2);
            remove(o->ch[d2],x);
        }
        else
        {
            if(o->ch[0]==NULL)
                o = o->ch[1];
            else o = o->ch[0];
        }
    }
    else
        remove(o->ch[d],x);

    if(o!=NULL) o->maintain();
}


const int maxc = 500000 + 10;
struct Command
{
    char type;
    int x,p;
} commands[maxc];

const int maxn = 20000 + 10;
const int maxm = 60000 + 10;
int n,m;
int weight[maxn],from[maxm],to[maxm],removed[maxm];


int pa[maxn];
int findset(int x)
{
    return pa[x]!=x ? pa[x] = findset(pa[x]):x;
}

Node* root[maxn];   //Treap

int kth(Node* o,int k)
{
    if(o==NULL||k<=0||k> o->s) return 0;
    int s = (o->ch[1]==NULL?0:o->ch[1]->s);
    if(k==s+1) return o->v;
    else if(k<=s) return kth(o->ch[1],k);
    else return kth(o->ch[0],k-s-1);
}

void mergeto(Node* &src,Node* &dest)
{
    if(src->ch[0]!=NULL) mergeto(src->ch[0],dest);
    if(src->ch[1]!=NULL) mergeto(src->ch[1],dest);
    insert(dest,src->v);
    delete src;
    src = NULL;
}

void removetree(Node* &x)
{
    if(x->ch[0]!=NULL) removetree(x->ch[0]);
    if(x->ch[1]!=NULL) removetree(x->ch[1]);
    delete x;
    x = NULL;
}

void add_edge(int x)
{
    int u = findset(from[x]),v=findset(to[x]);
    if(u!=v)
    {
        if(root[u]->s < root[v]->s)
        {
            pa[u] = v;
            mergeto(root[u],root[v]);
        }
        else
        {
            pa[v] = u;
            mergeto(root[v],root[u]);
        }
    }
}

int query_cnt;
long long query_tot;
void query(int x,int k)
{
    query_cnt++;
    query_tot +=kth(root[findset(x)],k);
}

void change_weight(int x,int v)
{
    int u = findset(x);
    remove(root[u],weight[x]);
    insert(root[u],v);
    weight[x] = v;
}


int main()
{
    int kase = 0;
    while(scanf("%d%d",&n,&m)==2&&n)
    {
        for(int i=1; i<=n; i++)
            scanf("%d",&weight[i]);
        for(int i=1; i<=m; i++)
            scanf("%d%d",&from[i],&to[i]);
        memset(removed,0,sizeof(removed));

        int c = 0;
        for(;;)
        {
            char type;
            int x,p=0,v = 0;
            scanf(" %c",&type);
            if(type=='E') break;
            scanf("%d",&x);
            if(type=='D') removed[x]= 1;    //删掉的边
            if(type=='Q') scanf("%d",&p);
            if(type=='C')
            {
                scanf("%d",&v);
                p = weight[x];
                weight[x] = v;
            }
            commands[c++] = (Command)
            {
                type,x,p
            };
        }

        //最终的图
        for(int i=1; i<=n; i++)
        {
            pa[i] = i;
            if(root[i]!=NULL) removetree(root[i]);
            root[i] = new Node(weight[i]);
        }
        for(int i=1; i<=m; i++)
        {
            if(!removed[i]) //id为i这条边没有被删掉
                add_edge(i);
        }

        query_cnt = query_tot = 0;
        for(int i=c-1; i>=0; i--)
        {
            if(commands[i].type=='D') add_edge(commands[i].x);  //加上边
            if(commands[i].type=='Q') query(commands[i].x,commands[i].p);//第p大
            if(commands[i].type=='C') change_weight(commands[i].x,commands[i].p);
        }

        printf("Case %d: %.6lf
",++kase,query_tot/(double)query_cnt);

    }



    return 0;
}