leetcode 547. Friend Circles

最新推荐文章于 2022-06-09 20:11:50 发布

huanghanqian

最新推荐文章于 2022-06-09 20:11:50 发布

阅读量646

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode leetcode

本文链接：https://blog.youkuaiyun.com/huanghanqian/article/details/73740935

leetcode 同时被 2 个专栏收录

261 篇文章

订阅专栏

leetcode

257 篇文章

订阅专栏

本文介绍了一种使用并查集算法解决朋友圈分组问题的方法。通过构建并查集来维护学生之间的直接或间接友谊关系，进而计算出朋友圈的数量。同时对比了深度优先搜索（DFS）方法，并分析了其时间效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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:

N is in range [1,200].
M[i][i] = 1 for all students.
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