[leetCode]547. 朋友圈

题目

链接：https://leetcode-cn.com/problems/friend-circles

班上有 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]

dfs

好友关系是一张无向图，可以将输入看作邻接矩阵，矩阵的下标代表顶点，M[i][j]代表顶点i与j之间存在一条边。使用一个visited数组来标记顶点i是否访问过。遍历顶点如果未访问则进行深度优先搜索，判断当前顶点和其他顶点之间是否存在边如果存在则继续深度搜索直到一个连通分量全部遍历完

class Solution {
    int n;
    public int findCircleNum(int[][] M) {
        n = M.length; // 无向图中顶点的个数
        boolean[] visited = new boolean[n]; // 标记顶点i是否访问
        int nums = 0; // 连通分量的个数
        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                dfs(M, i, visited);
                nums++;
            }
        }
        return nums;
    }

    private void dfs(int[][] M, int i, boolean[] visited) {
        visited[i] = true;
        for (int k = 0; k < n; k++) {
            if (M[i][k] == 1 && !visited[k]) {
                dfs(M, k, visited);
            }
        }
    }

}

题目已改为省份数量

https://leetcode-cn.com/problems/number-of-provinces/submissions/

广度优先搜索

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int n = isConnected.length;
        boolean[] visited = new boolean[n];
        Queue<Integer> queue = new LinkedList<>();
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                queue.offer(i);
                while (!queue.isEmpty()) {
                    int cur = queue.poll();
                    for (int j = 0; j < n; j++) {
                        if (isConnected[cur][j] == 1 && !visited[j]) {
                            visited[j] = true;
                            queue.offer(j);
                        }
                    }
                }
                cnt++;
            }
        }
        return cnt;
    }
}

并查集

初始时每个城市属于不同的连通分量。遍历矩阵isConnected如果两个城市是连通的则合并两个城市。遍历完isConnected矩阵后，计算连通分量的总数就得到了省分数

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int n = isConnected.length;
        UnionFind unionFind = new UnionFind(n);
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (isConnected[i][j] == 1) {
                    unionFind.union(i, j);
                }
            }
        }
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            if (unionFind.parent[i] == i) {
                cnt++;
            }
        }
        return cnt;
    }

    public class UnionFind {
        int[] parent;
        public UnionFind(int n) {
            parent = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
            }
        }

        public void union(int x, int y) {
            int rootX = findFull(x);
            int rootY = findFull(y);
            parent[rootX] = rootY;// 代表元法，将两个根结点相连
        }

        public int find(int x) {
            while (parent[x] != x) { // 隔代压缩
                parent[x] = parent[parent[x]];
                x = parent[x];
            }
            return x;
        }

        public int findFull(int x) { // 完全压缩，路径上的结点全部连在根结点上，效率低一些
            if (x != parent[x]) {
                parent[x] = findFull(parent[x]);
            }
            return parent[x];
        }
    }
}