HDU3726 UVA1749 Graph and Queries

Graph and Queries

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 2264 Accepted Submission(s): 510

Problem Description
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.


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

Hint
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




Source
2010 Asia Tianjin Regional Contest

第一次写treap。。。感觉和伸展树差不多，就是操作少了点。。。当做伸展树入门之前的一点准备。。。。。

这题是treap+离线处理+并查集。。。就是先把所有命令都存起来然后从后往前处理。。。因为要求删边。。离线处理过后就变成的加边，每一个连通分量里都有一棵树，加边的时候当两个点在一个连通分量里就不用做什么了，不在同一个连通分量里就要将这两个树合并。。注意要结点数少的合到结点数大的里面去。。。然后查询第k大就在一个连通分量里查询就可以了（第1大就是最右边的值，第二大就是右边从左边数第二个）。。。

注意 在remove操作了重复delete结点在HDU上交G++可能会WA。。在UVA上RE。。。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const int MAXC=500010;
const int MAXN=20010;
const int MAXM=60010;
struct Node
{
    Node *ch[2];
    int r;
    int s;
    int v;
    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)
    {
        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;
    }
};
struct Command
{
    char type;
    int x,p;
}commands[MAXC];
void rotate(Node* &root,int d)
{
    Node *k=root->ch[d^1];root->ch[d^1]=k->ch[d];k->ch[d]=root;
    root->maintain();k->maintain();root=k;
}
void insert(Node* &root,int x)
{
    if(root==NULL)
    {
        root=new Node(x);
    }
    else
    {
        int d=(x<root->v)?0:1;
        insert(root->ch[d],x);
        if(root->ch[d]->r>root->r)
            rotate(root,d^1);
    }
    root->maintain();
}
void remove(Node* &root,int x)
{
    int d=root->cmp(x);
    if(d==-1)
    {
        Node *u=root;
        if(root->ch[0]==NULL)
        {
            root=root->ch[1];
            delete u;
        }
        else if(root->ch[1]==NULL)
        {
            root=root->ch[0];
            delete u;
        }
        else
        {
            int d2=(root->ch[0]->r>root->ch[1]->r)?1:0;
            rotate(root,d2);
            remove(root->ch[d2],x);
        }
    }
    else
        remove(root->ch[d],x);
    if(root!=NULL)
        root->maintain();
}
int n,m,weight[MAXN],from[MAXM],to[MAXM],removed[MAXM];
int bin[MAXN];
Node *root[MAXN];
int find(int x)
{
    return bin[x]==x?x:bin[x]=find(bin[x]);
}
int kth(Node *root,int k)
{
    if(root==NULL||k<=0||k>root->s)
        return 0;
    int s=(root->ch[1]==NULL?0:root->ch[1]->s);
    if(k==s+1)
        return root->v;
    else if(k<=s)
        return kth(root->ch[1],k);
    else
        return kth(root->ch[0],k-s-1);
}
void merge(Node* &scr,Node* &dest)
{
    if(scr->ch[0]!=NULL)
        merge(scr->ch[0],dest);
    if(scr->ch[1]!=NULL)
        merge(scr->ch[1],dest);
    insert(dest,scr->v);
    delete scr;
    scr=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=find(from[x]),v=find(to[x]);
    if(u!=v)
    {
        if(root[u]->s<root[v]->s)
        {
            bin[u]=v;
            merge(root[u],root[v]);
        }
        else
        {
            bin[v]=u;
            merge(root[v],root[u]);
        }
    }
}
int query_cnt;
ll query_sum;
void query(int x,int k)
{
    query_cnt++;
    query_sum+=kth(root[find(x)],k);
}
void change_weight(int x,int v)
{
    int u=find(x);
    remove(root[u],weight[x]);
    insert(root[u],v);
    weight[x]=v;
}
int main()
{
    int n,m,i,flag=1;
    while(scanf("%d%d",&n,&m)==2&&(n||m))
    {
        for(i=1;i<=n;i++)
            scanf("%d",&weight[i]);
        for(i=1;i<=m;i++)
            scanf("%d%d",&from[i],&to[i]);
        memset(removed,0,sizeof(removed));
        int c=0;
        while(1)
        {
            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(i=1;i<=n;i++)
        {
            bin[i]=i;
            if(root[i]!=NULL)
                removetree(root[i]);
            root[i]=new Node(weight[i]);
        }
        for(i=1;i<=m;i++)
            if(!removed[i])
            add_edge(i);
        query_cnt=query_sum=0;
        for(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: %.6f\n",flag++,query_sum/(query_cnt*1.0));
    }
    return 0;
}