LA 5031 Graph and Queries （【名次树(treap)】+【并查集】+【离线算法】）

题目链接：https://cn.vjudge.net/problem/UVALive-5031

You are given an undirected graph with N vertexes and M edges. Every vertex in this graph has an
integer value assigned to it at the beginning. You’re also given a sequence of operations and you need
to process them as requested. Here’s a list of the possible operations that you might encounter:
1. Deletes an edge from the graph.
The format is [D X], where X is an integer from 1 to M, indicating the ID of the edge that you
should delete. It is guaranteed that no edge will be deleted more than once.
2. Queries the weight of the vertex with K-th maximum value among all vertexes currently
connected with vertex X (including X itself).
The format is [Q X K], where X is an integer from 1 to N, indicating the id of the vertex, and
you may assume that K will always fit into a 32-bit signed integer. In case K is illegal, the value
for that query will be considered as undefined, and you should return 0 as the answer to that
query.
3. Changes the weight of a vertex.
The format is [C X V ], where X is an integer from 1 to N, and V is an integer within the range
[−106
, 106
].
The operations end with one single character, ‘E’, which indicates that the current case has ended.
For simplicity, you only need to output one real number — the average answer of all queries.
Input
There are multiple test cases in the input file. Each case starts with two integers N and M (1 ≤ N ≤
2 ∗ 104
, 0 ≤ M ≤ 6 ∗ 104
), the number of vertexes in the graph. The next N lines describes the initial
weight of each vertex (−106 ≤ weight[i] ≤ 106
). The next part of each test case describes the edges
in the graph at the beginning. Vertexes are numbered from 1 to N. The last part of each test case
describes the operations to be performed on the graph. It is guaranteed that the number of query
operations [Q X K] in each case will be in the range [1, 2 ∗ 105
], and there will be no more than 2 ∗ 105
operations that change the values of the vertexes [C X V ].
There will be a blank line between two successive cases. A case with N = 0, M = 0 indicates the
end of the input file and this case should not be processed by your program.
Output
For each test case, output one real number — the average answer of all queries, in the format as
indicated in the sample output. Please note that the result is rounded to six decimal places.
Explanation for samples:
For the first sample:
D 3 – deletes the 3rd edge in the graph (the remaining edges are (1, 2) and (2, 3))
Q 1 2 – finds the vertex with the second largest value among all vertexes connected with 1. The
answer is 20.
Q 2 1 – finds the vertex with the largest value among all vertexes connected with 2. The answer is
30.
D 2 – deletes the 2nd edge in the graph (the only edge left after this operation is (1, 2))
Q 3 2 – finds the vertex with the second largest value among all vertexes connected with 3. The
answer is 0 (Undefined).
C 1 50 – changes the value of vertex 1 to 50.
Q 1 1 – finds the vertex with the largest value among all vertex connected with 1. The answer is 50.
E – This is the end of the current test case. Four queries have been evaluated, and the answer to
this case is (20 + 30 + 0 + 50) / 4 = 25.000.
For the second sample, caution about the vertex with same weight:
Q 1 1 – the answer is 20
Q 1 2 – the answer is 20
Q 1 3 – the answer is 10
Sample Input
3 3
10
20
30
1 2
2 3
1 3
D 3
Q 1 2
Q 2 1
D 2
Q 3 2
C 1 50
Q 1 1
E
3 3
10
20
20
1 2
2 3
1 3
Q 1 1
Q 1 2
Q 1 3
E
0 0
Sample Output
Case 1: 25.000000
Case 2: 16.666667

【中文题意】
有一张n个节点m条边的无向图，每个结点都有一个整数权值。你的任务是执行一系列操作。操作有如下三种：
1.D X(1<=X <=m) 删除ID为X的边，输入保证每条边至多被删除1次。
2.Q X k(1<=X <=n)，计算与节点X连通的结点中（包括X本身），第k大的权值，如果不存在，返回0 。
3.C X V (1<=x <=n)把结点X的权值改为V
操作序列结束的标志位单个字母E，节点编号为1~n,边编号为1~m。
输入格式
输入第一行为两个整数n和m（1<=n<=20000,0<=m<=60000），以下n行每行有一个绝对值不超过10^6 的整数，即各结点的初始权值，以下m行每行有两个整数，即一条边的两个端点。接下来是每条指令，以单个字母E结尾。保证Q和C的指令均不超过200000条，输入结束标志位n=m=0。
输出格式
对于每组数据，输出所有Q指令的计算结果的平均值，精确到小数点后6位。
【分析】
本题只需要设计离线算法，因此可以把操作的顺序反过来处理，先读入所有操作，执行所有的D操作得到最终的图，然后按照逆序把这些边逐步插入，并在恰当的时机执行Q和C操作。用一棵名次树维护一个联通分量中的点权，则C操作对应名次树中一次修改操作（可以用一次删除加一次插入来实现），Q操作对应kth操作，而执行D操作时，如果两个端点已经是一个同一连通分量则无影响，否则将两个端点对应的名次树合并。
【AC代码】

#include<cstdlib>#include<cstdio>#include<cstring>#include<cmath>#include<algorithm>#include<vector>#include<map>#include<set>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;//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)//对o结点进行旋转，0代表左旋，1代表右旋，旋转后更新结点域{    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)//插入一个值为x的结点{    if(o==NULL)o=new Node(x);    else    {        int d=(x<o->v?0:1);//x< o->v 时d=0该节点被插入左边，否则d=1插入右边        insert(o->ch[d],x);        if(o->ch[d]>o)rotate(o,d^1);//如果被插入后优先级比父节点大，要发生旋转    }    o->maintain();}void remove(Node* &o,int x)//删除一个值为x的节点{    int d=o->cmp(x);    if(d==-1)//d==1时代表代表需删除的节点为当前节点    {        Node* u=o;        if(o->ch[0]!=NULL&&o->ch[1]!=NULL)//左右孩子非空        {            int d2=(o->ch[0] > o->ch[1] ?1:0);//左孩子与右孩子谁的优先级比较高            rotate(o,d2);//谁的高向另外的方向旋转            remove(o->ch[d2],x);//旋转后删除x节点        }        else        {            if(o->ch[0]==NULL)o=o->ch[1];//左孩子为空，o指向右孩子            else o=o->ch[0];//否则指向左孩子            delete u;        }    }    else        remove(o->ch[d],x);    if(o!=NULL)o->maintain();//删除后o有孩子的话更新结点域}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,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];//Treapint kth(Node* o,int k)//查找以o为根节点的子树中的第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;//正好第k大为当前节点    else if(k<=s)    {        return kth(o->ch[1],k);//第k大在右子树上    }    else return kth(o->ch[0],k-s-1);//第k大在左子树上}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)//删除根节点为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)//增加第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)//查询与x联通的所有结点中的第k大{    query_cnt++;    query_tot+=kth(root[findset(x)],k);}void change_weight(int x,int v)//把结点x的值改为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])add_edge(i);        }        //反向操作        query_tot = query_cnt=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);            if(commands[i].type=='C')                change_weight(commands[i].x,commands[i].p);        }        printf("Case %d: %.6lf\n",++kase,query_tot/(double)query_cnt);    }    return 0;}