leetcode 323.无向图中连通分量的数目 Java

最新推荐文章于 2023-12-05 17:28:54 发布

原创最新推荐文章于 2023-12-05 17:28:54 发布 · 1.8k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #dfs

leetcode刷题专栏收录该内容

260 篇文章

订阅专栏

这篇博客介绍了如何利用深度优先搜索(DFS)或广度优先搜索(BFS)算法解决LeetCode上的无向图连通分量数量计算问题。给出的代码模板分别使用了两种方法，通过构建邻接矩阵并进行遍历来找到所有连通分量，最终返回其数量。示例展示了不同连通性的图结构及其对应的答案。

无向图中连通分量的数目

做题博客链接
题目链接
描述
示例
初始代码模板
代码

做题博客链接

https://blog.youkuaiyun.com/qq_43349112/article/details/108542248

题目链接

https://leetcode-cn.com/problems/number-of-connected-components-in-an-undirected-graph/

描述

给定编号从 0 到 n-1 的 n 个节点和一个无向边列表（每条边都是一对节点），请编写一个函数来计算无向图中连
分量的数目。

注意:
你可以假设在 edges 中不会出现重复的边。而且由于所以的边都是无向边，[0, 1] 与 [1, 0]  相同，所以它们不会
同时在 edges 中出现。

示例

示例 1:

输入: n = 5 和 edges = [[0, 1], [1, 2], [3, 4]]

     0          3
     |          |
     1 --- 2    4 

输出: 2

示例 2:

输入: n = 5 和 edges = [[0, 1], [1, 2], [2, 3], [3, 4]]

     0           4
     |           |
     1 --- 2 --- 3

输出:  1

初始代码模板

class Solution {
    public int countComponents(int n, int[][] edges) {

    }
}

代码

思路不难，直接看代码就可以。
不用数组用list也可以

BFS

class Solution {
    public int countComponents(int n, int[][] edges) {
        int[][] arr = new int[n][n];
        for (int[] cur : edges) {
            arr[cur[0]][cur[1]] = 1;
            arr[cur[1]][cur[0]] = 1;
        }

        boolean[] vis = new boolean[n];
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                res++;
                bfs(vis, arr, i, n);
            }
        }

        return res;
    }

    private void bfs(boolean[] vis, int[][] arr, int idx, int n) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(idx);

        while (!queue.isEmpty()) {
            for (int size = queue.size(); size > 0; size--) {
                int loc = queue.poll();
                for (int i = 0; i < n; i++) {
                    if (arr[loc][i] == 1 && !vis[i]) {
                        vis[i] = true;
                        queue.offer(i);
                    }
                }
            }
        }
    }
}

DFS

class Solution {
    public int countComponents(int n, int[][] edges) {
        int[][] arr = new int[n][n];
        for (int[] cur : edges) {
            arr[cur[0]][cur[1]] = 1;
            arr[cur[1]][cur[0]] = 1;
        }

        boolean[] vis = new boolean[n];
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                res++;
                dfs(vis, arr, i, n);
            }
        }

        return res;
    }

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