uvalive 5031

L - Graph and Queries

Time Limit:3000MS    Memory Limit:0KB    64bit IO Format:%lld & %llu

Submit Status

Appoint description:

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 [-10⁶, 10⁶].

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 (1N2 * 10⁴, 0M6 * 10⁴), the number of vertexes in the graph. The next N lines describes the initial weight of each vertex (- 10⁶[weight][i]10⁶). 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 * 10⁵], and there will be no more than 2 * 10⁵ 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

一个图，一堆操作，计算多次查询的第k大平均值。

离线读入命令，逆序操作，平衡树启发式合并，

代码：

/* ***********************************************
Author :xianxingwuguan
Created Time :2014/3/4 12:48:23
File Name :G.cpp
************************************************ */
#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <time.h>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
typedef long long ll;
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]>o)rotate(o,d^1);
	}
	o->maintain();
}
void remove(Node* &o,int x){
	int d=o->cmp(x);
	if(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);
		}
		else{
			if(o->ch[0]==NULL)o=o->ch[1];
			else o=o->ch[0];
			delete u;
		}
	}
	else remove(o->ch[d],x);
	if(o!=NULL)o->maintain();
}
const int maxc=500040;
struct Command{
	char type;
	int x,p;
}command[maxc];
const int maxn=200010;
const int maxm=100100;
int n,m,weight[maxn],from[maxm],to[maxm],removed[maxn];
int pa[maxn];
int find(int x){
	if(pa[x]!=x)pa[x]=find(pa[x]);
	return pa[x];
}
Node *root[maxn];
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);
	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=find(from[x]);
	int v=find(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;
ll query_tot;
void query(int x,int k){
	query_cnt++;
	query_tot+=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 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;
            }
            command[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(command[i].type == 'D')
                add_edge(command[i].x);
            if(command[i].type == 'Q')
                query(command[i].x, command[i].p);
            if(command[i].type == 'C')
                change_weight(command[i].x, command[i].p);
        }
        printf("Case %d: %.6lf\n", ++kase, query_tot / (double)query_cnt);
    }
    return 0;
}