LA 5031 Graph and Queries Treap

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

题意：有一张n个结点m条边的无向图，每个结点都有一个整数权值。要求执行3种操作

      D X 删除ID为X的边

      Q X K 计算与结点X连通的结点中，第K大的权值，如果不存在输出0

      C X V 把结点X的权值改为V

思路：离线处理，需要用到并查集和Treap树。。保存所有的命令。然后建立最终的图，即D了的边全都先不连。

      反向遍历命令：

      D命令则添边。注意添边得合并两棵树。可递归实现。这里按秩合并可以省时间。

      Q命令没什么说的。

      C命令就是简单的删点和添点。

#include <cstdlib>

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 & a) const
	{
		return r < a.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);//这里不要用cmp，因为可能有相同的数
		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();
}

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);
}

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

#define maxn 500010
#define maxm 80080
#define LL long long int
struct Command
{
	char type;
	int x,k;
}commands[maxn];
int from[maxm],to[maxm];//用来存边
bool removed[maxm];//用来标记边是否已经去除

//并查集相关
int father[maxm],weight[maxm];
int find(int x)
{
	if(x == father[x])	return x;
	return father[x] = find(father[x]);
}

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

void removeto(Node *& src,Node *& dest)//按秩合并能更省时间
{
	if(src -> ch[0])	removeto(src -> ch[0],dest);
	if(src -> ch[1])	removeto(src -> ch[1],dest);
	insert(dest,src -> v);
	delete src;
	src = NULL;
}

	
Node * root[maxm];
void Union(int a,int b)
{
	int fa = find(a),fb = find(b);
	if(fa == fb)	return;
	if(root[fa] -> s > root[fb] -> s)
	{
		removeto(root[fb],root[fa]);
		father[fb] = fa;
	}
	else 
	{
		removeto(root[fa],root[fb]);
		father[fa] = fb;
	}
}

void Chang_weight(int x,int k)
{
	remove(root[find(x)],weight[x]);
	insert(root[find(x)],k);
	weight[x] = k;
}


int main()
{
	//freopen("in.txt","r",stdin);
	int n,m,cas = 0;
	while(scanf("%d%d",&n,&m)==2 && n)
	{
		cas++;
		memset(removed,0,sizeof(removed));
		for(int i = 1;i <= n;i++)
		{
			father[i] = i;
			scanf("%d",&weight[i]);
			if(root[i] != NULL)	removetree(root[i]);
		}
		
		for(int i = 1;i <= m;i++)//边
		{
			int u,v;
			scanf("%d%d",&u,&v);
			from[i] = u;
			to[i] = v;
		}

		int query_cnt = 0;
		int cnt = 1;
		LL sum = 0;
		while(1)
		{
			int x = 0,k;
			char type;
			scanf(" %c",&type);
			if(type == 'D')
			{
				scanf("%d",&k);
				removed[k] = 1;
			}
			if(type == 'Q')
			{
				scanf("%d%d",&x,&k);
				query_cnt++;
			}
			if(type == 'C')
			{
				scanf("%d%d",&x,&k);
				int p = weight[x];
				weight[x] = k;
				k = p;
			}
			if(type == 'E')	break;
			commands[cnt].type = type;
			commands[cnt].x = x;
			commands[cnt++].k = k;
		}
		
		//建立最终的图
		for(int i = 1;i <= n;i++)	root[i] = new Node(weight[i]);
		for(int i = 1;i <= m;i++)
		{
			if(!removed[i])
			{
				int u = from[i],v = to[i];
				Union(u,v);
			}
		}
		
		//接下来就是命令了
		//反向遍历命令
		for(int i = cnt-1;i >= 1;i--)
		{
			int k = commands[i].k,x = commands[i].x;
			switch(commands[i].type)
			{
			case('D'):
			{
				int u = from[k],v = to[k];
				Union(u,v);
				break;
			}
			case('Q'):
			{
				sum += kth(root[find(x)],k);
				break;
			}
			case('C'):
			{
				Chang_weight(x,k);
			}
			}
		}

		printf("Case %d: %.6lf\n",cas,sum/(double)query_cnt);
	}
	return 0;
}