[LeetCode] 547. Friend Circles

最新推荐文章于 2020-04-23 20:02:42 发布

转载最新推荐文章于 2020-04-23 20:02:42 发布 · 51 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/chencode/p/friend-circles.html

本文介绍了一个基于并查集算法解决的朋友圈圈子问题。通过使用Java实现的并查集数据结构来计算在一个社交网络中存在多少个独立的朋友圈子。具体实现了初始化并查集、查找根节点和合并两个节点的方法。

https://leetcode.com/problems/friend-circles

public class Solution {
    int[] id;
    int[] weight;
    public int findCircleNum(int[][] M) {
        if (M == null || M.length == 0 || M[0].length == 0) {
            return 0;
        }
        initUnionFind(M.length);
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < M.length; i++) {
            for (int j = 0; j < M[0].length; j++) {
                if (i == j) {
                    continue;
                }
                if (M[i][j] == 1) {
                    union(i, j);
                }
            }
        }
        for (int i = 0; i < id.length; i++) {
            int root = find(i);
            if (!set.contains(root)) {
                set.add(root);
            }
        }
        return set.size();
    }
    
    private void initUnionFind(int n) {
        id = new int[n];
        weight = new int[n];
        for (int i = 0; i < n; i++) {
            id[i] = i;
            weight[i] = 1;
        }
    }
    private void union(int i, int j) {
        int rootI = find(i);
        int rootJ = find(j);
        if (rootI == rootJ) {
            return;
        }
        if (weight[rootI] > weight[rootJ]) {
            id[rootJ] = rootI;
            weight[rootI] += weight[rootJ];
        } else {
            id[rootI] = rootJ;
            weight[rootJ] += weight[rootI];
        }
    }
    private int find(int i) {
        while (i != id[i]) {
            return find(id[i]);
        }
        return i;
    }
}

转载于:https://www.cnblogs.com/chencode/p/friend-circles.html