leetcode_547_朋友圈_并查集解法

package cn.leetcode.circleoffriends_547;

import java.util.HashSet;

/**
 * 班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。
 * 给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。
 *
 * 示例 1：
 * 输入：
 * [[1,1,0],
 * [1,1,0],
 * [0,0,1]]
 * 输出：2
 * 解释：已知学生 0 和学生 1 互为朋友，他们在一个朋友圈。
 * 第2个学生自己在一个朋友圈。所以返回 2 。
 *
 * 示例 2：
 * 输入：
 * [[1,1,0],
 * [1,1,1],
 * [0,1,1]]
 * 输出：1
 * 解释：已知学生 0 和学生 1 互为朋友，学生 1 和学生 2 互为朋友，所以学生 0 和学生 2 也是朋友，所以他们三个在一个朋友圈，返回 1 。
 *
 * 提示：
 * 1 <= N <= 200
 * M[i][i] == 1
 * M[i][j] == M[j][i]
 *
 * 参考资料：https://www.cnblogs.com/noKing/p/8018609.html
 */
public class Solution {

    public static void main(String[] args) {
//        int[][] arr = new int[][]{{1, 1, 0}, {1, 1, 0}, {0, 0, 1}};
        int[][] arr = new int[][]{{1, 0, 0, 1}, {0, 1, 1, 0}, {0, 1, 1, 1}, {1, 0, 1, 1}};
        Solution s = new Solution();

        System.out.println(s.findCircleNum(arr));
    }

    /**
     * 一共又多少个朋友圈
     * @param M
     * @return
     */
    public int findCircleNum(int[][] M) {
        UnionFind union = new UnionFind(M.length);
        int ret = union.findCircleNum(M);
//        union.printArr();
        return ret;
    }


}

/**
 *并查集具体实现
 */
class UnionFind {
    private static int[] leader;
    private static int[] weight;
    private static int size;

    /**
     * 一共有多少个组
     * @param M
     * @return
     */
    public static int findCircleNum(int[][] M) {
        for (int i = 0; i < M.length; i++) {
            for (int j = 0; j < M[i].length; j++) {
                if (M[i][j] != 0 && i != j) {
                    unionElements(i, j);
                }
            }
        }
        //用HashSet不重复性记录有多少个不同的组
        int leaderVal=0;
        HashSet<Integer> set = new HashSet();
        for (int i = 0; i < leader.length; i++) {
            leaderVal=find(leader[i]);
            set.add(leaderVal);
        }
        return set.size();
    }

    /**
     * 构造函数
     * @param size
     */
    public UnionFind(int size) {
        this.leader = new int[size];
        this.weight = new int[size];
        this.size = size;
        for (int i = 0; i < size; i++) {
            this.leader[i] = i;
            this.weight[i] = 1;
        }
    }

    /**
     * 查询最终teamLeader的值
     * @param element
     * @return
     */
    public static int find(int element) {
        while (element != leader[element]) {
            leader[element] = leader[leader[element]]; // 路径压缩 (非最终leader结点)
            element = leader[element];
        }
        return element;
    }

    public static boolean isConnected(int firstElement, int secondElement) {
        return find(firstElement) == find(secondElement);
    }

    public static void unionElements(int firstElement, int secondElement) {
        int firstRoot = find(firstElement);
        int secondRoot = find(secondElement);

        //如果已经属于同一个集合了，就不用再合并了。
        if (firstRoot == secondRoot) {
            return;
        }
        //谁小弟多谁说了算
        if (weight[firstRoot] > weight[secondRoot]) {
            leader[secondRoot] = firstRoot;
            weight[firstRoot] += weight[secondRoot];
        } else {
            leader[firstRoot] = secondRoot;
            weight[secondRoot] += weight[firstRoot];
        }
    }

    public static void printArr() {
        for (int p : leader) {
            System.out.print(p + "\t");
        }
        System.out.println();
    }

}