数据结构与算法实战 5.2并查集与集合 （青岛大学 周强）

*****不相交集*****(Disjoint Set)
先来看等价类:


不相交集也叫“并查集”，指的是这个集合更多的操作是并和查，不是集合叫并查集- -
集合，一般的集合，主要考虑集合有什么元素，根据集合查元素
不相交集，主要考虑，给定一个元素，去找这个元素在哪个集合.

因为我们要根据任意一个元素找到属于的集合，如果用树的话每次都要从树根出发找到元素
所以我们考虑用线性结构去做并查集，直接就能找到某个元素，比如数组

查找和并
实际上 我们希望并查集里面所有的元素，除了树根以外都是直接指着树根，只有两层!!!
否则的话，就会让树越来越高，查找会变得很低效
有三种方法：Union by size 把小树并到大树上去
            Union by height(tank) 把矮树并到高树上
            Path compression 路径压缩 + unionBySize
什么叫路径压缩？ 比如 c->b->a->root
                find(C)压缩为 c->root 省略掉路过的不是root的点

利用C++的stl的set实现并查集

#include<iostream>
#include<set>
#include<map>

using namespace std;

template<class T>
struct DisjointSet{//用类也行 只是老师用了结构体- -
    int *parent;//创建时再动态分配空间大小 存父节点下标
    T* data;//存节点的数据
    int capacity;//最大容量
    int size;//为什么需要这个size?因为我们会动态去删除增加元素，不一定就是固定死了就是capacity
    map<T, int> m;//数据 数据下标
    //构造函数
    DisjointSet(int max=10){//最大容量，没有赋值就默认为10
            capacity = max;
            size = 0;
            parent = new int[max + 1];
            data = new T[max + 1];
    //我们定义，用0表示没有父亲 用1往下的数字表示它的父亲是哪个位置的点
    //所以0号元素我们不用，上面得+1
    }
    ~DisjointSet(){
        delete [] parent;
        delete [] data;
    }
    //插入 因为有容量限制 可能会失败 要返回插入成功or失败
    //插入到最后那个元素的后面 也就是最新的空位置的开端
    bool insert(T x){
        //我们规定按照插入顺序占据数据空间
        //注意！！0号位置我们不存东西
        if(size == capacity){
            return false;
        }
        size ++;//新插入一个 ++
        data[size] = x;
        parent[size] = -1;//新插入时候我们默认每个元素都是独立子集 没有父节点
        m[x] = size;//实际上map里面不是一个数组，但是可以这样用
        return true;
    }
    void print(){
        for(int i = 1; i <= size; i ++){
            //元素的下标 元素的父亲 元素本身
            cout << i << "\t";
        }
        cout << endl;
        for(int i = 1; i <= size; i ++){
            //元素的下标 元素的父亲 元素本身
            cout << parent[i] << "\t";
        }
        cout << endl;
        for(int i = 1; i <= size; i ++){
            //元素的下标 元素的父亲 元素本身
            cout << data[i] << "\t";
        }
        cout << endl;
    }
    int find(T x){
        /*
        int i;//元素是几号
        i = getIndex(x);
        //找元素i的父亲
        parent[i]；
        顺序查找的效率是O(N) 效率比较低 我们可以用map(映射 key-value的形式)
        map底层用散列or红黑树实现
        map <data, (data's)index>
        插入的时候应该就要确定map 所以应该是struct的变量
        */
       //测试
       //cout << m[x] << endl; 这样写的话，如果查找的元素不存在，map会自动插入然后和0号位置绑定，是错误的
       //故m[x]只能用于确定x是存在的时候才能使用
       //测试
       //因为map里面有一个template，所以不能直接map<T, int>::iterator it;
       int i;
       typename map<T, int>::iterator it;
       it = m.find(x);
       if(it == m.end()) return -1;//找不到
       int rt;//root
       rt = it->second;//second就是数据的下标
       cout << x << "的父节点下标" << i << endl;
       //找树根
       while(parent[rt] > 0)//=0才是树根嘛，大于0就铁定不是树根啦
       {
           rt = parent[rt];//一直找，找到父亲为止
       }
       //while 退出时候，i必定<=0,即找到了树根
       /***实现路径压缩***/
       //为什么不用递归呢？实际上如果传入的是节点的位置的话，递归比较好做的
       //但是这里传进的是节点的值，难以回溯，所以我们在这里只能用循环去实现路径压缩
       //从x .... 到rt（树根）为止，路上碰到的每一个数据都让他直接指向rt
       //it是x的下标，rt是树根的下标
       int tmp;
       for(int i = m[x]; i != rt; i = tmp){
           tmp = parent[i];//不能改变树根，所以采用了临时变量
           parent[i] = rt;
       }
       return rt;
    }
    //并操作
    //直接并两个树根 并两棵树
    /*void unionSet(int r1, int r2){//谨记！！C++ 和C里面有一个数据结构是Union
        parent[r2] = r1;

    }*/

    //直接并两个树根不太高效 改为路径压缩+小树并大树(按照size合并的操作
    void unionSet(T x, T y){
        cout << "运行并操作" << endl; 
        int rx, ry;//x's root, y's root
        rx = find(x);
        ry = find(y);
        //可能元素不存在
          if(rx == -1 || ry == -1){
            return ;//不存在
        }
        //同一个集合也不需要合并
        if(rx == ry) {
            return;
        }    
        //为了利用size 我们在insert中改为树根为-1
        //我们规定，root是size的相反数
        //rx 和 ry都是负数，当rx < ry的时候，rx这棵树大一点
        if(parent[rx] < parent[ry]){//把ry集合合并到rx集合中去
            parent[rx] +=parent[ry];//把元素个数合并
            parent[ry] = rx;
            
        }
        else{//ry这棵树大一点 合并rx到ry集合中去
            parent[ry] += parent[rx];
            parent[rx] = ry;
            
        }
        cout << "运行并操作结束" << endl; 
    }
    //unionTest
    /*void Test(){
        unionSet(1, 3);
        unionSet(2, 4);
        unionSet(4, 5);
        print();
    }*/
};

int main(){
    DisjointSet<int> s;
    s.insert(11);
    s.insert(22);
    s.insert(66);
    s.insert(-5);
    s.insert(123);
    s.print();
    //Find 找这个元素的父子集是谁
    //根据数据找下标（父亲） 父亲再继续找到0为止
    //使用者只会知道元素数据 所以参数就是元素数据
    //返回下标就可以 用户得到下标 就能快速找到这个数据
    s.unionSet(11, 66);
    s.print();
    cout << "-------------" << endl;
    s.unionSet(22, 11);
    s.print();

    return 0;
}

//实例：推断学生所属学校 集合并查集结合使用
题目：某个比赛现场有来自不同学校的N名学生，给出M对“两人同属一所学校”的关系，
      请推断学校数量，并给出人数最多的学校的学生名单。
输入格式： 先输入一个在[2, 1000]的整数N，然后是N个用空格间隔的姓名。
          接下来一行是正整数M，M行，每行两个人名，表示同属一个学校。

输出格式：先输出学校的数量，在下一行输出人数最多的学校的学生名单。

输入样例：
    8
    Bill Ellen Ann Chris Daisy Flin Henry Grace
    5
    Ann Chris
    Ellen Chris
    Daisy Flin
    Henry Ellen
    Grace Flin
利用上面写过的DisjointSet完成

#include<iostream>
#include<set>
#include<map>

using namespace std;

template<class T>
struct DisjointSet{//用类也行 只是老师用了结构体- -
    int *parent;//创建时再动态分配空间大小 存父节点下标
    T* data;//存节点的数据
    int capacity;//最大容量
    int size;//为什么需要这个size?因为我们会动态去删除增加元素，不一定就是固定死了就是capacity
    map<T, int> m;//数据 数据下标
    
/*因为并查集中每个元素在find完成之后都是指向父节点，所以很难说找到一个集合出来，
那么我们就得从根节点往下一个一个的找，然后才能找到全部的集合元素出来，极其麻烦
那么我们就需要结合原生的set一起用*/
    set<T> *mates;//同学集合 用指针一样是为了动态分配空间大小
    //构造函数
    DisjointSet(int max=10){//最大容量，没有赋值就默认为10
            capacity = max;
            size = 0;
            parent = new int[max + 1];
            data = new T[max + 1];
    //我们定义，用0表示没有父亲 用1往下的数字表示它的父亲是哪个位置的点
    //所以0号元素我们不用，上面得+1

            mates = new set<T>[max + 1];//同学集合
    }
    ~DisjointSet(){
        delete [] parent;
        delete [] data;
    }
    //插入 因为有容量限制 可能会失败 要返回插入成功or失败
    //插入到最后那个元素的后面 也就是最新的空位置的开端
    bool insert(T x){
        //我们规定按照插入顺序占据数据空间
        //注意！！0号位置我们不存东西
        if(size == capacity){
            return false;
        }
        size ++;//新插入一个 ++
        data[size] = x;
        parent[size] = -1;//新插入时候我们默认每个元素都是独立子集 没有父节点
        m[x] = size;//实际上map里面不是一个数组，但是可以这样用
        //因为默认刚加入的时候自己是一个独立集合 所以同学只有自己
        mates[size].insert(x);
        return true;
    }
    void print(){
        for(int i = 1; i <= size; i ++){
            //元素的下标 元素的父亲 元素本身
            cout << i << "\t";
        }
        cout << endl;
        for(int i = 1; i <= size; i ++){
            //元素的下标 元素的父亲 元素本身
            cout << parent[i] << "\t";
        }
        cout << endl;
        for(int i = 1; i <= size; i ++){
            //元素的下标 元素的父亲 元素本身
            cout << data[i] << "\t";
        }
        cout << endl;
    }
    int find(T x){
        /*
        int i;//元素是几号
        i = getIndex(x);
        //找元素i的父亲
        parent[i]；
        顺序查找的效率是O(N) 效率比较低 我们可以用map(映射 key-value的形式)
        map底层用散列or红黑树实现
        map <data, (data's)index>
        插入的时候应该就要确定map 所以应该是struct的变量
        */
       //测试
       //cout << m[x] << endl; 这样写的话，如果查找的元素不存在，map会自动插入然后和0号位置绑定，是错误的
       //故m[x]只能用于确定x是存在的时候才能使用
       //测试
       //因为map里面有一个template，所以不能直接map<T, int>::iterator it;
       int i;
       typename map<T, int>::iterator it;
       it = m.find(x);
       if(it == m.end()) return -1;//找不到
       int rt;//root
       rt = it->second;//second就是数据的下标
       cout << x << "的父节点下标" << i << endl;
       //找树根
       while(parent[rt] > 0)//=0才是树根嘛，大于0就铁定不是树根啦
       {
           rt = parent[rt];//一直找，找到父亲为止
       }
       //while 退出时候，i必定<=0,即找到了树根
       /***实现路径压缩***/
       //为什么不用递归呢？实际上如果传入的是节点的位置的话，递归比较好做的
       //但是这里传进的是节点的值，难以回溯，所以我们在这里只能用循环去实现路径压缩
       //从x .... 到rt（树根）为止，路上碰到的每一个数据都让他直接指向rt
       //it是x的下标，rt是树根的下标
       int tmp;
       for(int i = m[x]; i != rt; i = tmp){
           tmp = parent[i];//不能改变树根，所以采用了临时变量
           parent[i] = rt;
       }
       return rt;
    }
    //并操作
    //直接并两个树根 并两棵树
    /*void unionSet(int r1, int r2){//谨记！！C++ 和C里面有一个数据结构是Union
        parent[r2] = r1;

    }*/

    //直接并两个树根不太高效 改为路径压缩+小树并大树(按照size合并的操作
    void unionSet(T x, T y){
        cout << "运行并操作" << endl; 
        int rx, ry;//x's root, y's root
        rx = find(x);
        ry = find(y);
        //可能元素不存在
          if(rx == -1 || ry == -1){
            return ;//不存在
        }
        //同一个集合也不需要合并
        if(rx == ry) {
            return;
        }    
        //为了利用size 我们在insert中改为树根为-1
        //我们规定，root是size的相反数
        //rx 和 ry都是负数，当rx < ry的时候，rx这棵树大一点
        if(parent[rx] < parent[ry]){//把ry集合合并到rx集合中去
            parent[rx] +=parent[ry];//把元素个数合并
            parent[ry] = rx;
            //实例新增
            mates[rx].insert(mates[ry].begin(), mates[ry].end());
            //因为ry已经放进去了rx,所以ry清空得了，省空间
            mates[ry].clear();
        }
        else{//ry这棵树大一点 合并rx到ry集合中去
            parent[ry] += parent[rx];
            parent[rx] = ry;
            mates[ry].insert(mates[rx].begin(), mates[rx].end());
            //因为rx已经放进去了ry,所以ry清空得了，省空间
            mates[rx].clear();
        }
        cout << "运行并操作结束" << endl; 
    }
};

int main(){
    int M,N;
    cin >> N;
    DisjointSet<int> s(N);
    string name;
    for(int i = 0; i < N; i ++){
        cin >> name;
        s.insert(name);
    }
    cint >> M;
    string name2;
    for(int i = 0; i < M; i ++){
        cin >> name >> name2;
        s.unionSet(name, name2);
    }
    //结构体的属性都是Public的 main可以直接调用
    int maxid = 0;//最大值的树根是哪个
    int maxsize = 0;//最大人数
    int numOfSchools = 0;//学校数量
    for(int i=1; i<=N; i++){
        if(s.mates[i].size()>0) numOfSchools++; //发现一所学校，则数量+1
        if(s.parent[i] < maxsize) {
            maxsize = s.parent[i];
            maxid = i;
        }
    }
    cout << numOfSchools << endl;  //打印学校的数量
    for(auto x : s.mates[maxid])  //打印人数最多的学校的学生名单
        cout << x << ' ';
    cout << endl;
    return 0;
}