poj 1988(并查集)

Cube Stacking

Time Limit: 2000MS		Memory Limit: 30000K
Total Submissions: 13788		Accepted: 4650
Case Time Limit: 1000MS

Description

Farmer John and Betsy are playing a game with N (1 <= N <= 30,000)identical cubes labeled 1 through N. They start with N stacks, each containing a single cube. Farmer John asks Betsy to perform P (1<= P <= 100,000) operation. There are two types of operations: 
moves and counts. 
* In a move operation, Farmer John asks Bessie to move the stack containing cube X on top of the stack containing cube Y. 
* In a count operation, Farmer John asks Bessie to count the number of cubes on the stack with cube X that are under the cube X and report that value. 

Write a program that can verify the results of the game. 

Input

* Line 1: A single integer, P 

* Lines 2..P+1: Each of these lines describes a legal operation. Line 2 describes the first operation, etc. Each line begins with a 'M' for a move operation or a 'C' for a count operation. For move operations, the line also contains two integers: X and Y.For count operations, the line also contains a single integer: X. 

Note that the value for N does not appear in the input file. No move operation will request a move a stack onto itself. 

Output

Print the output from each of the count operations in the same order as the input file. 

Sample Input

6
M 1 6
C 1
M 2 4
M 2 6
C 3
C 4

Sample Output

1
0
2

Source

USACO 2004 U S Open

题目类型：并查集

题目描述：两个人玩挪木块的游戏，有两种操作。

(1) M a b : 把a所在那堆木块，移到b所在的那堆木块的上方。

(2) C a : 查询a的下方有多少木块。

题目分析：合并+维护，但是自己一开始那种维护方法不对，每次合并后都需要花费O(n)来维护。果断的TLE，之前有道题TLE也是因为每次合并后需要花费O(n)来维护。显然，以后对于每次合并后都需要花费O(n)来维护的方法都是不可取的。自己一开始也想了，合并时不需要维护，利用每次的find_root()来维护。但是没想到策略。

看了别人的解题报告，他的策略是，通过维护down[x](x木块下方有多少木块)和up[x](x木块上方有多少木块)。

x下面的木块数=down[find_root(x)]-up[x]

所以对于down[]来说，我们只需要维护根节点的down[]。

合并的时候维护down[] up[],find的时候维护up[]

代码如下：

#include <iostream>
#include <stdio.h>
#define N 30005
using namespace std;

int f[N];
int up[N];
int down[N];

void init(){
    for(int i = 1; i < N ;i++) {
        f[i] = i;
        up[i] = 0;
        down[i] = 0;
    }
}
int find(int x){
    if(f[x] == x){
        return x;
    } else {
        int temp = f[x];
        f[x] = find(f[x]);
        if(temp != f[x]) {
            up[x] += up[temp];
        }
        return f[x];
    }
}
void merge(int a,int b){
    int ra = find(a);
    int rb = find(b);
    if(ra != rb){
        f[rb] = ra;
        up[rb] = down[ra] + 1; //维护rb的up
        down[ra] += down[rb]+1;//维护ra的down
    }
}

int main()
{
    init();
    int p,a,b;
    char ch;
    scanf("%d",&p);
    while(p--){
        getchar();
        ch = getchar();
        if(ch == 'C') {
            scanf("%d",&a);
            int root = find(a);

            printf("%d\n",down[root]-up[a]);
        } else {
            scanf("%d%d",&a,&b);
            merge(a,b);
        }

    }
    return 0;
}