AcWing 238. 银河英雄传说

有一个划分为 N 列的星际战场，各列依次编号为 1,2,…,N。

有 N 艘战舰，也依次编号为 1,2,…,N，其中第 i 号战舰处于第 i 列。

有 T 条指令，每条指令格式为以下两种之一：

1. M i j，表示让第 i 号战舰所在列的全部战舰保持原有顺序，接在第 j 号战舰所在列的尾部。

2. C i j，表示询问第 i 号战舰与第 j 号战舰当前是否处于同一列中，如果在同一列中，它们之间间隔了多少艘战舰。

现在需要你编写一个程序，处理一系列的指令。

输入格式

第一行包含整数 T，表示共有 T 条指令。

接下来 T行，每行一个指令，指令有两种形式：M i j 或 C i j。

其中 M和 C为大写字母表示指令类型，i和 j为整数，表示指令涉及的战舰编号。

输出格式

你的程序应当依次对输入的每一条指令进行分析和处理：

如果是 M i j 形式，则表示舰队排列发生了变化，你的程序要注意到这一点，但是不要输出任何信息；

如果是 C i j 形式，你的程序要输出一行，仅包含一个整数，表示在同一列上，第 i 号战舰与第 j 号战舰之间布置的战舰数目，如果第 i 号战舰与第 j号战舰当前不在同一列上，则输出 −1。

数据范围

N≤30000,T≤500000

输入样例：

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

输出样例：

-1
1

算法分析：

并查集可以用于维护具有传递性关系的作用，每个集合的大小，绑定到根结点上，每个点到根结点的距离，绑定到每个元素的结点上

1. s[x]表示集合的大小，d[x]表示x到p[x]的距离

2. 将第a列的船接在第b列的末尾，相当于让每个点到pb的距离都加上s[pb]，由于存储并查集中存在路径压缩的效果，因此只需要将pa到pb的距离加上s[pb]即可，即d[pa] = s[pb]，其他跟着pa后面的元素会通过对路径进行压缩且更新d[i]的值

3、路径压缩的过程

(1)、找到根结点root

(2)、计算父节点到上一个父节点的距离d[p[x]],同时进行路径压缩(路径压缩后，上一父节点即root)

(3)、d[x]初始值是x到p[x]的距离，更新d[x]值，即d[x] = d[x] + d[p[x]]

时间复杂度

并查集操作接近O(1)

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 30010;
int a[N],t,p[N],d[N],s[N];//d[N]代表i到根节点的距离,s[N]代表根节点中点的个数

int find(int x)  // 并查集
{
    if(p[x]!=x)
    {
        int root=find(p[x]);
        d[x]+=d[p[x]];
        p[x]=root;
    }
    return p[x];
}

void join(int x,int y)
{
    x=find(x);y=find(y);
    if(x!=y)
    {
        p[x]=y;
        d[x]=s[y];
        s[y]+=s[x];
    }
}
int main()
{
    int t;
    for (int i = 0; i <30010; i ++ )
    {
        p[i]=i;s[i]=1;
    }
    cin >> t;
    while(t--)
    {
        char c;
        int x,y;
        cin >> c >> x >>y;
        if(c=='M')
        {
            join(x,y);
        }
        else{
            if(find(x)!=find(y))
            {
                cout << "-1" << endl;
            }
            else
            {
                cout << max(0,abs(d[x]-d[y])-1) <<endl;
            }
        }
    }
    return 0;
}