并查集

并查集的定义：

      并查集是一种数据结构，它提供两种基本的操作，并和查。

      1、并：将两个集合合并；

      2、查：查询两个元素是否在同一集合中或查询一个元素所在的集合。

要实现这两种基本操作，需要的数据结构只需满足两个条件：

      1、每一个集合都有唯一一个根节点；

      2、每一个节点都知道自己的父节点是谁！

如果要将两个集合合并只需要将一个根节点指向另外一个根节点。

如果要判断两个节点是否在同一个集合中，就将这两个节点往上溯，判断这两个节点是否具有相同的根节点。

并查集的实现：用数组来实现。元素用数组的索引来表示，元素的父节点用索引上的值来表示。

例题1、亲戚

【问题描述】

若某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，求任意给出的两个人是否具有亲戚关系。

规定：x和y是亲戚，y和z是亲戚，那么x和z也是亲戚。如果x,y是亲戚，那么x的亲戚都是y的亲戚，y的亲戚也都是x的亲戚。 

【输入】

    第一行：三个整数n,m,p，（n<=5000,m<=5000,p<=5000），分别表示有n个人，m个亲戚关系，询问p对亲戚关系。

以下m行：每行两个数Mi，Mj，1<=Mi，Mj<=N，表示Ai和Bi具有亲戚关系。

    接下来p行：每行两个数Pi，Pj，询问Pi和Pj是否具有亲戚关系。  

【输出】

    P行，每行一个‘Yes’或‘No’。表示第i个询问的答案为“具有”或“不具有”亲戚关系。

【样例输入】

9 7 3

2 4

5 7

1 3

8 9

1 2

5 6

2 3

2 5

2 4

3 8

【样例输出】

No

Yes

No

例2：mty的考验(RQNOJ343)

啊!几经周折.mty终于找到了他的偶像.他就是....fyc!

可是fyc这样的高级人士可不喜欢一个人总是缠着他.于是他出了一道难题想考考mty.fyc有几个手下:陈乐天,舒步鸡,胡巍......现在fyc要去和别人fight,需要组建一值军队.军队的士兵在fyc的手下里选.

要组建一个军队,必修满足军队中的每个人之间都有直接或间接的朋友关系.

那么mty现在需要组建一支在满足上述情况下的人数最多的军队.

1<=n<=1000,1<=m<=500.

【输入格式】第一行,两个数,n,m.(n表示fyc有几个手下m表示有m对朋友关系).一下m行,每行两个数.x[i],y[i].表示编号为x[i],y[i]的人是朋友.

【输出格式】一个数,表示人数最多的军队的人数.

【样例输入】

5 3

1 2

2 3

3 4

【样例输出】

4

说明:1,2,3,4可组成一直军队.

例题3、关押罪犯（noip2010）

【问题描述】

S 城现有两座监狱，一共关押着N 名罪犯，编号分别为1~N。他们之间的关系自然也极

不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨

气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之

间的积怨越多。如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并

造成影响力为c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，

然后上报到S 城Z 市长那里。公务繁忙的Z 市长只会去看列表中的第一个事件的影响力，

如果影响很坏，他就会考虑撤换警察局长。

在详细考察了N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在

两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只

要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那

么，应如何分配罪犯，才能使Z 市长看到的那个冲突事件的影响力最小？这个最小值是多

少？

【输入】

输入文件名为prison.in。输入文件的每行中两个数之间用一个空格隔开。第一行为两个正整数N 和M，分别表示罪犯的数目以及存在仇恨的罪犯对数。接下来的M 行每行为三个正整数aj，bj，cj，表示aj 号和bj 号罪犯之间存在仇恨，其怨气值为cj。数据保证a b N j j 1 ≤ < ≤ ，0 < ≤ 1,000,000,000 j c ，且每对罪犯组合只出现一次。

【输出】

输出文件prison.out 共1 行，为Z 市长看到的那个冲突事件的影响力。如果本年内监狱

中未发生任何冲突事件，请输出0。

【样例输入】

4 6

1 4 2534

2 3 3512

1 2 28351

1 3 6618

2 4 1805

3 4 12884

【样例输出】

3512

程序输出：

NO

YES

NO

4

3512

Process finished with exit code 0

程序如下：

import java.util.*;

/**
 * @author liyiwen1
 * @date 2016/12/8
 */
public class MergingFindingSet {
    public static void main(String[] args) {
        resolveProblem1UsingMergingFindSet();
        resolveProblem2UsingMergingFindSet();
        resolveProblem3UsingMergingFindSet();
    }

    public static void resolveProblem2UsingMergingFindSet(){
        MergingFindingSet mergingFindingSet = new MergingFindingSet(6);
        mergingFindingSet.join(1, 2);
        mergingFindingSet.join(2, 3);
        mergingFindingSet.join(3,4);
        System.out.println(mergingFindingSet.getMaxSetSize());
    }

    public static void resolveProblem3UsingMergingFindSet(){
        ArrayList<CriminalHatred> criminalHatreds = new ArrayList<CriminalHatred>();
        criminalHatreds.add(new CriminalHatred(1,4,2534));
        criminalHatreds.add(new CriminalHatred(2,3,3512));
        criminalHatreds.add(new CriminalHatred(1,2,28351));
        criminalHatreds.add(new CriminalHatred(1,3,6618));
        criminalHatreds.add(new CriminalHatred(2,4,1805));
        criminalHatreds.add(new CriminalHatred(3,4,12884));
        Collections.sort(criminalHatreds);
        MergingFindingSet mergingFindingSet = new MergingFindingSet(5);
        int set1Root = criminalHatreds.get(0).criminal1;//集合1的根
        int set2Root = criminalHatreds.get(0).criminal2;//集合2的根
        for (int i = 1; i < criminalHatreds.size(); i++){
            CriminalHatred criminalHatred = criminalHatreds.get(i);
            if (i >= 2){
                if (mergingFindingSet.isSameSet(criminalHatred.getCriminal1(), criminalHatred.getCriminal2())){
                    System.out.println(criminalHatred.getHatred());
                    break;
                }
            }
            Set<Integer> all = new HashSet<Integer>();
            all.addAll(mergingFindingSet.getSet(set1Root));
            all.addAll(mergingFindingSet.getSet(set2Root));
            if (all.contains(criminalHatred.criminal1) && all.contains(criminalHatred.criminal2)){
                continue;
            }
            if (mergingFindingSet.getSet(set1Root).contains(criminalHatred.criminal1)){
                mergingFindingSet.join(criminalHatred.criminal2, set2Root);
                continue;
            }else if (mergingFindingSet.getSet(set2Root).contains(criminalHatred.criminal1)){
                mergingFindingSet.join(criminalHatred.criminal2, set1Root);
                continue;
            }

            if (mergingFindingSet.getSet(set1Root).contains(criminalHatred.criminal2)){
                mergingFindingSet.join(criminalHatred.criminal1, set2Root);
                continue;
            }else if (mergingFindingSet.getSet(set2Root).contains(criminalHatred.criminal2)){
                mergingFindingSet.join(criminalHatred.criminal1, set1Root);
                continue;
            }

            handel(criminalHatreds, i, set1Root, set2Root, mergingFindingSet);
        }
    }

    private static void handel(ArrayList<CriminalHatred> criminalHatreds, int i, int set1Root, int set2Root,
                                         MergingFindingSet mergingFindingSet){
        Set<Integer> integers1 = mergingFindingSet.getSet(set1Root);
        Set<Integer> integers2 = mergingFindingSet.getSet(set2Root);
        Set<Integer> set = new HashSet<Integer>();
        set.add(criminalHatreds.get(i).criminal1);
        set.add(criminalHatreds.get(i).criminal2);
        for (int m = i + 1; m < criminalHatreds.size(); m++){
            if (set.contains(criminalHatreds.get(m).criminal1) ){
                int a = criminalHatreds.get(m).criminal2;
                if (integers1.contains(a)){
                    mergingFindingSet.join(criminalHatreds.get(m).criminal1, set2Root);
                    mergingFindingSet.join(criminalHatreds.get(i).criminal2 == criminalHatreds.get(m).criminal1?
                            criminalHatreds.get(i).criminal1:criminalHatreds.get(i).criminal2, set1Root);
                    break;
                }else if (integers2.contains(a)){
                    mergingFindingSet.join(criminalHatreds.get(m).criminal1, set1Root);
                    mergingFindingSet.join(criminalHatreds.get(i).criminal2 == criminalHatreds.get(m).criminal1
                            ?criminalHatreds.get(i).criminal1:criminalHatreds.get(i).criminal2, set2Root);
                    break;
                }
            }else if (set.contains(criminalHatreds.get(m).criminal2)){
                int a = criminalHatreds.get(m).criminal1;
                if (integers1.contains(a)){
                    mergingFindingSet.join(criminalHatreds.get(m).criminal2, set2Root);
                    mergingFindingSet.join(criminalHatreds.get(i).criminal1 == criminalHatreds.get(m).criminal2? criminalHatreds.get(i).criminal2:
                            criminalHatreds.get(i).criminal1, set1Root);
                    break;
                }else if (integers2.contains(a)){
                    mergingFindingSet.join(criminalHatreds.get(m).criminal2, set1Root);
                    mergingFindingSet.join(criminalHatreds.get(i).criminal1 == criminalHatreds.get(m).criminal2?criminalHatreds.get(i).criminal2:
                            criminalHatreds.get(i).criminal1, set2Root);
                    break;
                }
            }
        }
    }

    private static class CriminalHatred implements Comparable<CriminalHatred>{
        private int criminal1;
        private int criminal2;
        private int hatred;

        public CriminalHatred(int criminal1, int criminal2, int hatred) {
            this.criminal1 = criminal1;
            this.criminal2 = criminal2;
            this.hatred = hatred;
        }

        @Override
        public int compareTo(CriminalHatred criminalHatred){
            return criminalHatred.hatred - this.hatred;
        }

        public int getCriminal1() {
            return criminal1;
        }

        public void setCriminal1(int criminal1) {
            this.criminal1 = criminal1;
        }

        public int getCriminal2() {
            return criminal2;
        }

        public void setCriminal2(int criminal2) {
            this.criminal2 = criminal2;
        }

        public int getHatred() {
            return hatred;
        }

        public void setHatred(int hatred) {
            this.hatred = hatred;
        }
    }

    static private class Pair implements Comparable<Pair>{
        private int root;
        private int size;

        public int getRoot() {
            return root;
        }

        public void setRoot(int root) {
            this.root = root;
        }

        public int getSize() {
            return size;
        }

        public void setSize(int size) {
            this.size = size;
        }

        public Pair(int root, int size) {
            this.root = root;
            this.size = size;
        }

        @Override
        public int compareTo(Pair o1){
            return this.size - o1.size;
        }
    }

    //找出最大集合的元素个数
    public int getMaxSetSize(){
        HashMap<Integer, Pair> integerPairHashMap = new HashMap<Integer, Pair>();
        for (int i = 1; i < array.length - 1; i++){
            Pair pair = integerPairHashMap.get(getRoot(i));
            if (pair == null){
                integerPairHashMap.put(getRoot(i), new Pair(getRoot(i), 1));
            }else{
                pair.size++;
            }
        }
        int maxSize = 0;
        for (Map.Entry<Integer, Pair> pairEntry : integerPairHashMap.entrySet()){
            if (pairEntry.getValue().getSize() > maxSize){
                maxSize = pairEntry.getValue().getSize();
            }
        }
        return maxSize;
    }
    public static void resolveProblem1UsingMergingFindSet(){
        MergingFindingSet mergingFindingSet = new MergingFindingSet(10);
        mergingFindingSet.join(2, 4);
        mergingFindingSet.join(5, 7);
        mergingFindingSet.join(1,3);
        mergingFindingSet.join(8,9);
        mergingFindingSet.join(1,2);
        mergingFindingSet.join(5,6);
        mergingFindingSet.join(2,3);
        if (mergingFindingSet.isSameSet(2, 5)){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
        if (mergingFindingSet.isSameSet(2, 4)){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
        if (mergingFindingSet.isSameSet(3, 8)){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }

    private int[] array;

    public MergingFindingSet(int length){
        array = new int[length];
        init();
    }

    private void init(){
        if (array != null && array.length != 0){
            for (int i = 0; i < array.length; i++){
                array[i] = i;
            }
        }
    }

    //获取和a处于同一个集合的所有元素
    public Set<Integer> getSet(int a){
        Set<Integer> integers = new HashSet<Integer>();
        integers.add(a);
        int root = getRoot(a);
        if (root != a){
            for (int i = 1; i < array.length; i++){
                if (getRoot(i) == root){
                    integers.add(i);
                }
            }
        }
        return integers;
    }

    //判断a和b是否在相同的集合
    public boolean isSameSet(int a, int b){
        return getRoot(a) == getRoot(b);
    }
    //将a元素和b元素所在的两个集合合并
    public void join(int a, int b){
        int rootA = getRoot(a);
        int rootB = getRoot(b);
        if (rootA != rootB){
            array[rootA] = rootB;
        }
    }

    //找到a的根节点
    private int getRoot(int a){
        int b = a;
        while (array[b] != b){
            b = array[b];
        }
        if (a != b){
            array[a] = b;//路径压缩
        }
        return b;
    }

}