547. Friend Circles (M)

Friend Circles (M)

There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. For example, if A is a direct friend of B, and B is a direct friend of C, then A is an indirect friend of C. And we defined a friend circle is a group of students who are direct or indirect friends.

Given a N*N matrix M representing the friend relationship between students in the class. If M[i][j] = 1, then the ith and jth students are direct friends with each other, otherwise not. And you have to output the total number of friend circles among all the students.

Example 1:

Input: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle. 
The 2nd student himself is in a friend circle. So return 2.

Example 2:

Input: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
Output: 1
Explanation:The 0th and 1st students are direct friends, the 1st and 2nd students are direct friends, 
so the 0th and 2nd students are indirect friends. All of them are in the same friend circle, so return 1.

Note:

1. N is in range [1,200].
2. M[i][i] = 1 for all students.
3. If M[i][j] = 1, then M[j][i] = 1.

---

题意

给定N个学生和各个学生之间的交友关系(自反性，传递性，对称性)，具有相连交友关系的学生归类为一个朋友圈，要求输出形成的朋友圈数目。

思路

非常典型的并查集应用，每个朋友圈即一个连通分量，求所有节点连接完毕后连通分量的数目。

---

代码实现

class Solution {
    public int findCircleNum(int[][] M) {
        int num = M.length;
        UF uf = new UF(num);
        for (int i = 0; i < num; i++) {
            for (int j = i + 1; j < num; j++) {
                if (M[i][j] == 1) {
                    uf.union(i, j);
                }
            }
        }
        return uf.count;
    }
    
    
    class UF {
        int count;		// 记录连通分量数目
        int[] id;
        int[] height;  	// 记录树高
        
        public UF(int n) {
            count = n;
            id = new int[n];
            height = new int[n];
            for (int i = 0; i < n; i++) {
                id[i] = i;
                height[i] = 0;
            }
        }
        
        public int count() {
            return count;
        }
        
        public int find(int x) {
            int root = x;
            while (root != id[root]) {
                root = id[root];
            }
            // 利用路径压缩使树扁平化
            while (x != root) {
                int temp = id[x];
                id[x] = root;
                x = temp;
            }
            return root;
        }
        
        public void union (int p, int q) {
            int pRoot = find(p);
            int qRoot = find(q);
            
            if (pRoot == qRoot) {
                return;
            }
            
            // 利用树高进行优化
            if (height[pRoot] < height[qRoot]) {
                id[pRoot] = qRoot;
            } else {
                id[qRoot] = pRoot;
                // 当且仅当两树高相等才会使合并后的树高+1
                if (height[pRoot] == height[qRoot]) {
                    height[pRoot]++;
                }
            }
            
            // 每一次union操作都会减少一个连通分量
            count--;
        }
    }
}