校赛 (离散化 + 并查集)

题目描述

狗逼喵养了只小喵呜，编号1-N。第i只小喵呜懂M_i种语言。
俗话说得好，语言不通怎么啪啪啪，所以只有当两只小喵呜懂相同的语言的时候他们才能交流才能成为好朋♂友♀。

当然就算两只小喵呜不懂同一种语言也可以请其他小喵呜当翻译。换句话说，小喵呜A和小喵呜B可以成为好朋友的前提是存在一个序列A，T_1,T_2,…..,T_k，B(k>=0)，其中A和T_1都会说某一种语言，T_1和T_2也都会说某一种语言…..,并且T_k和B会说某一种语言。

狗逼喵希望他的小喵呜都能成为好朋♂友♀，于是他决定买一些技能书教某些小喵呜一些语言。但是狗逼喵最近比较穷他想知道他最少需要买多少本书。（注：一本书仅能对一只喵呜使用，并且只能教会这只喵呜一种语言）

输入格式

第一行输入一个整数T，表示有T组数据，对于每组数据，第一行输入一个n表示有n(n<=10000)只小喵呜，接下来输入n行。第i行先输入一个M_i（0<=M_i<=10）表示第i只小喵呜懂M_i种语言。接下来输入M_i个数表示这只小喵呜懂的语言编号(1<=编号<=10^7)

输出

每组数据输出一个数，表示狗逼喵最少要买多少本书。

样例输入

1
3
1 1
2 1 2
1 3

样例输出

1

思路：利用一个record的数组来记录其中一只会第i种语言的猫的编 号。然后并查集。但是注意，因为猫会的语言的编号是1~10^7，但是总共有10^4只猫，每只猫至多会10种语言。所以总共可能出现的语言数最多为10^5。所以需要离散化。

#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;

struct Miao {
    int cat;
    int lantot;
    int language[11];
}M[100005];
int al;
int reflex[100005];//离散化
int record[100005];
int f[100005];

int Find(int x) {
    if (f[x] == x) return x;
    return f[x] = Find(f[x]);
}

int BinarySearch(int x) {
    int l = 0, r = al;
    if (reflex[r] == x) return r;
    while (r - l > 1) {
        int m = (l + r) >> 1;
        if (reflex[m] > x)
            r = m;
        else
            l = m;
    }
    return l;
}

int main() {
    int t;
    scanf("%d", &t);
    for (int ca = 1; ca <= t; ca++) {
        int n, all = 0;
        scanf("%d", &n);
        al = 0;
        for (int i = 1; i <= n; i++) {
            int m;
            scanf("%d", &m);
            M[i].lantot = 0;
            M[i].cat = i;
            for (int j = 1; j <= m; j++) {
                int x;
                scanf("%d", &x);
                M[i].language[M[i].lantot++] = x; 
                reflex[all++] = x;
            }
        }

        //离散化
        sort(reflex, reflex + all);
        for (int i = 1; i < all; i++)
            if (reflex[i] != reflex[al]) reflex[++al] = reflex[i];

        //并查集
        for (int i = 1; i <= n; i++) f[i] = i;
        memset(record, 0, sizeof(record));

        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < M[i].lantot; j++) {
                int x = BinarySearch(M[i].language[j]) + 1;
                if (record[x] == 0) 
                    record[x] = M[i].cat;
                f[Find(M[i].cat)] = Find(record[x]);
            }
        }

        for (int i = 1; i <= n; i++) f[i] = Find(i);
        sort(f + 1, f + n + 1);

        int x = f[1];
        int need = 0;

        for (int i = 1; i <= n; i++) {
            if (f[i] != x) {
                need++;
                x = f[i];
            }
        }
        printf("%d\n", need);
    }
    return 0;
}