leetcode 547. Friend Circles

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.

我本来想用根据图形的方法如果边上是00了则count++，但是写不出。。然后我就想到了昨天看到的并查集。虽然不太懂，但是套过来真的好有用啊！！！另外，自己写的parent[]根本不对，我本来想用并查集的思想自己写的，但是失败了，如果只用一个parent数组实现并查集的话，看我的后一篇博文。现在我们看下我自己写的失败的例子。

1   0   0   1

0   1   1   0

0   1   1   1

1   0   1   1

有如下有关系的对：

( 0, 3 )

( 1, 2 )

( 2, 3 )

如果只用一个parent数组的话，并且只在每个关系对后更新的话

parent[]:

index:0 1 2 3

value:0 1 1 0

这只写到(1,2)之后，然后(2,3)你会发现没法弄。

下面代码是用到了Union Find，并查集。Remember the template, you will be able to use it later.

package leetcode;

import java.util.HashMap;
import java.util.Map;

public class Friend_Circles_547 {
	class UnionFind {  
        private int count = 0;  
        private int[] parent, rank;  
          
        public UnionFind(int n) {  
            count = n;  
            parent = new int[n];  
            rank = new int[n];  
            for (int i = 0; i < n; i++) {  
                parent[i] = i;  
            }  
        }  
          
        public int find(int p) {  
            int q = parent[p];  
            while (q != parent[q]) {  
                q = parent[q];  
            }  
            parent[p] = q;  
            return q;  
        }  
          
        public void union(int p, int q) {  
            int rootP = find(p);  
            int rootQ = find(q);  
            if (rootP == rootQ) return;  
            if (rank[rootQ] > rank[rootP]) {  
                parent[rootP] = rootQ;  
            }  
            else {  
                parent[rootQ] = rootP;  
                if (rank[rootP] == rank[rootQ]) {  
                    rank[rootP]++;  
                }  
            }  
            count--;  
        }  
          
        public int count() {  
            return count;  
        }  
          
        public int getMaxUnion() {  
            Map<Integer, Integer> map = new HashMap<>();  
            int max = 1;  
            for (int i = 0; i < parent.length; i++) {  
                int p = find(i);  
                map.put(p, map.getOrDefault(p, 0) + 1);  
                max = Math.max(max, map.get(p));  
            }  
            return max;  
        } 
        
    }  

	int findParent(int[] parent,int index){
		while(parent[index]!=index){
			index=parent[index];
		}
		return index;
	}

	public int findCircleNum(int[][] M) {
		int n=M.length;
		int heng=0;
		int shu=0;
        UnionFind uf = new UnionFind(n);  
		for(shu=0;shu<n;shu++){
			for(heng=shu;heng<n;heng++){//因为是对角线对称的，所以只要看右上角部分
				if(M[shu][heng]==1){
					uf.union(shu, heng);
				}				
			}
		}
		return uf.count; 
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Friend_Circles_547 f=new Friend_Circles_547();
		int[][] M=new int[][]{
			{1,1,0},
			{1,1,1},
			{0,1,1}
		};
		System.out.println(f.findCircleNum(M));
	}

}

当然也有大神从数组入手，用DFS。

public class Solution {
    public void dfs(int[][] M, int[] visited, int i) {
        for (int j = 0; j < M.length; j++) {
            if (M[i][j] == 1 && visited[j] == 0) {
                visited[j] = 1;
                dfs(M, visited, j);
            }
        }
    }
    public int findCircleNum(int[][] M) {
        int[] visited = new int[M.length];
        int count = 0;
        for (int i = 0; i < M.length; i++) {
            if (visited[i] == 0) {
                dfs(M, visited, i);
                count++;
            }
        }
        return count;
    }
}

可以看下面这个例子，运用了上述的DFS解法后的步骤。

1   0   0   1

0   1   1   0

0   1   1   1

1   0   1   1

visited数组:

index:  0    1    2    3

value:  0    0    0    0

dfs(0)

visited[0]=1

dfs(0)

0    1    2    3

1    0    0    0

visited[3]=1;

dfs(3)

0    1    2    3

1    0    0    1

visited[2]=1;

dfs(2)

0    1    2    3

1    0    1    1

visited[1]=1;

dfs(1)

0    1    2    3

1    1    1    1

可以看到，是抓到了一个节点之后，就找与这个节点相关的所有节点，再找与相关的所有节点相关的所有节点，这些所有相关的都会在相同的group中。但是这种解法的时间复杂度，我相信是肯定不如并查集的。