【POJ】poj 1988（并查集_点到跟的距离）

 

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

这是一个并查集的问，只不过计算下面有多少个的时候计算所有的数量，并且减去这个上面的数量；详细见代码注释
 

 

 

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
struct group
{
    int fa;///他的父亲节点
    int up;///表示上面有多少个；
    int under;///表示下面有多少个，其中包括他自身；
}gro[30005];

void init( int n)
{
    for ( int i = 0; i < n; i++ )
    {
        gro[i].fa = i;
        gro[i].up = 0;///它上面的初始化为0；
        gro[i].under = 1;///他下面的初始化为1，因为包括自身
    }
}

int finds(int x)
{
    if ( gro[x].fa == x )
        return x;
    int p = gro[x].fa;
    gro[x].fa = finds(gro[x].fa);///将这个节点加入到根节点的下面；下面一行是计算它上面的数量
    gro[x].up += gro[p].up;///自行YY
    return gro[x].fa;
}



void unit( int x,int y)
{
     y = finds(y);
     x = finds(x);

     gro[y].fa = x;
     gro[y].up = gro[x].under;///y上方的就是放在y上方的一堆的总数，其中包括上方的根节点，既表达为gro[x].under
     gro[x].under += gro[y].under;
}
/*
bool same(int x, int y )
{
    return finds(x) == finds(y);
}
*/
int counts ( int x )
{
    int ans = 0;
    int y = finds(x);
    ans = gro[y].under - gro[x].up-1;///极端出总数，由于uo不包括自身，所以最后要-1，就是减去自身；
    return ans;
}

int main()
{
    //freopen("in.txt","r",stdin);
    //memset( vis,0,sizeof(vis));
    init(30000);
    int num;
    cin >> num;
    while ( num > 0 )
    {
        num--;
        char oper;
        cin >> oper;
        int fir,sec;

        if ( oper =='M' )
        {
            cin >> fir >> sec;
            unit( fir, sec );
        }
        if ( oper =='C' )
        {
            int x;
            cin >> x;
            cout << counts(x) << endl;
        }
    }
}