HDU 3726 Graph and Queries（离线 + Treap)

Graph and Queries

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5338    Accepted Submission(s): 1131

 

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

题意：

N个点，M条边的图。每个点有一个对应的权值。

然后下面由三种操作：

1： D X :删掉第X条边。

2： Q  X  K ：查询和X相连的点中 第K大的点的值（K=1表示最大，K=2表示第二大，。。。。）

3： C X V ：将点X的权值修改为V

思路：这道题需要离线处理，然后把操作顺序反过来处理，这样的话我们可以把删除边操作变成添加边的操作。用一棵名次树来维护一个连通分量的点权，C操作对应名次树的一次修改操作（可以用一次删除和一次插入来实现），Q操作对应名次树的Kth操作，执行D操作时，如果两个点已经在同一连通分量里则无需操作，否则将两个端点对应的名次树合并，启发式合并

#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& rhs) const
    {
        return r < rhs.r;
    }
    int cmp(int x) const
    {
        if(x == v) return -1;
        else 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 = o;
        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];
            delete u;
        }
    }
    else Remove(o -> ch[d],x);
    if(o != NULL) o -> maintain();
}

#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

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 ? x : pa[x] = findset(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);
    else return kth(o -> ch[0],k - s - 1);
}
void Merge(Node* &src,Node* &dest)
{
    if(src -> ch[0] != NULL) Merge(src -> ch[0],dest);
    if(src -> ch[1] != NULL) Merge(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;
            Merge(root[u],root[v]);
        }
        else {
            pa[v] = u;
            Merge(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(void)
{
    int kase = 0;
    while(scanf("%d%d",&n,&m) == 2 && (n + m) ) {
        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;
        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;
            else if(type == 'Q') scanf("%d",&p);
            else {
                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);
            else if(commands[i].type == 'Q') query(commands[i].x,commands[i].p);
            else change_weight(commands[i].x,commands[i].p);
        }
        printf("Case %d: %.6lf\n",++kase,query_tot / (double)query_cnt);
    }
    return 0;
}