Skip to content

Commit 88a131a

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.323 (doocs#2991)
No.323.Number of Connected Components in an Undirected Graph
1 parent 5eb7f4c commit 88a131a

File tree

7 files changed

+454
-62
lines changed

7 files changed

+454
-62
lines changed

‎solution/0300-0399/0323.Number of Connected Components in an Undirected Graph/README.md

+161-21
Original file line numberDiff line numberDiff line change
@@ -494,39 +494,179 @@ function countComponents(n: number, edges: number[][]): number {
494494

495495
<!-- solution:start -->
496496

497-
### 方法 3: BFS
497+
### 方法三：BFS
498+
499+
我们也可以使用 BFS 来统计图中的连通分量。
500+
501+
与方法一类似，我们首先根据给定的边构建一个邻接表 $g$，然后遍历所有节点，对于每个节点，如果它没有被访问过，我们就从该节点开始进行 BFS 遍历，将所有与其相邻的节点都标记为已访问，直到所有与其相邻的节点都被访问过，这样我们就找到了一个连通分量，答案加一。
502+
503+
遍历所有节点后，我们就得到了图中连通分量的数目。
504+
505+
时间复杂度 $O(n + m)$，空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别是节点数和边数。
498506

499507
<!-- tabs:start -->
500508

501-
#### TypeScript
509+
#### Python3
502510

503-
```ts
504-
function countComponents(n: number, edges: number[][]): number {
505-
const g: number[][] = Array.from({ length: n }, () => []);
506-
const vis = new Set<number>();
507-
let ans = 0;
511+
```python
512+
class Solution:
513+
def countComponents(self, n: int, edges: List[List[int]]) -> int:
514+
g = [[] for _ in range(n)]
515+
for a, b in edges:
516+
g[a].append(b)
517+
g[b].append(a)
518+
vis = set()
519+
ans = 0
520+
for i in range(n):
521+
if i in vis:
522+
continue
523+
vis.add(i)
524+
q = deque([i])
525+
while q:
526+
a = q.popleft()
527+
for b in g[a]:
528+
if b not in vis:
529+
vis.add(b)
530+
q.append(b)
531+
ans += 1
532+
return ans
533+
```
534+
535+
#### Java
508536

509-
for (const [i, j] of edges) {
510-
g[i].push(j);
511-
g[j].push(i);
537+
```java
538+
class Solution {
539+
public int countComponents(int n, int[][] edges) {
540+
List<Integer>[] g = new List[n];
541+
Arrays.setAll(g, k -> new ArrayList<>());
542+
for (var e : edges) {
543+
int a = e[0], b = e[1];
544+
g[a].add(b);
545+
g[b].add(a);
546+
}
547+
int ans = 0;
548+
boolean[] vis = new boolean[n];
549+
for (int i = 0; i < n; ++i) {
550+
if (vis[i]) {
551+
continue;
552+
}
553+
vis[i] = true;
554+
++ans;
555+
Deque<Integer> q = new ArrayDeque<>();
556+
q.offer(i);
557+
while (!q.isEmpty()) {
558+
int a = q.poll();
559+
for (int b : g[a]) {
560+
if (!vis[b]) {
561+
vis[b] = true;
562+
q.offer(b);
563+
}
564+
}
565+
}
566+
}
567+
return ans;
512568
}
569+
}
570+
```
513571

514-
const dfs = (i: number) => {
515-
if (vis.has(i)) return;
572+
#### C++
516573

517-
vis.add(i);
518-
for (const j of g[i]) {
519-
dfs(j);
574+
```cpp
575+
class Solution {
576+
public:
577+
int countComponents(int n, vector<vector<int>>& edges) {
578+
vector<int> g[n];
579+
for (auto& e : edges) {
580+
int a = e[0], b = e[1];
581+
g[a].push_back(b);
582+
g[b].push_back(a);
520583
}
521-
};
584+
vector<bool> vis(n);
585+
int ans = 0;
586+
for (int i = 0; i < n; ++i) {
587+
if (vis[i]) {
588+
continue;
589+
}
590+
vis[i] = true;
591+
++ans;
592+
queue<int> q{{i}};
593+
while (!q.empty()) {
594+
int a = q.front();
595+
q.pop();
596+
for (int b : g[a]) {
597+
if (!vis[b]) {
598+
vis[b] = true;
599+
q.push(b);
600+
}
601+
}
602+
}
603+
}
604+
return ans;
605+
}
606+
};
607+
```
522608
523-
for (let i = 0; i < n; i++) {
524-
if (vis.has(i)) continue;
609+
#### Go
525610
526-
dfs(i);
527-
ans++;
528-
}
611+
```go
612+
func countComponents(n int, edges [][]int) (ans int) {
613+
g := make([][]int, n)
614+
for _, e := range edges {
615+
a, b := e[0], e[1]
616+
g[a] = append(g[a], b)
617+
g[b] = append(g[b], a)
618+
}
619+
vis := make([]bool, n)
620+
for i := range g {
621+
if vis[i] {
622+
continue
623+
}
624+
vis[i] = true
625+
ans++
626+
q := []int{i}
627+
for len(q) > 0 {
628+
a := q[0]
629+
q = q[1:]
630+
for _, b := range g[a] {
631+
if !vis[b] {
632+
vis[b] = true
633+
q = append(q, b)
634+
}
635+
}
636+
}
637+
}
638+
return
639+
}
640+
```
641+
642+
#### TypeScript
529643

644+
```ts
645+
function countComponents(n: number, edges: number[][]): number {
646+
const g: number[][] = Array.from({ length: n }, () => []);
647+
for (const [a, b] of edges) {
648+
g[a].push(b);
649+
g[b].push(a);
650+
}
651+
const vis: boolean[] = Array(n).fill(false);
652+
let ans = 0;
653+
for (let i = 0; i < n; ++i) {
654+
if (vis[i]) {
655+
continue;
656+
}
657+
vis[i] = true;
658+
++ans;
659+
const q: number[] = [i];
660+
while (q.length) {
661+
const a = q.pop()!;
662+
for (const b of g[a]) {
663+
if (!vis[b]) {
664+
vis[b] = true;
665+
q.push(b);
666+
}
667+
}
668+
}
669+
}
530670
return ans;
531671
}
532672
```

‎solution/0300-0399/0323.Number of Connected Components in an Undirected Graph/README_EN.md

+160-20
Original file line numberDiff line numberDiff line change
@@ -491,37 +491,177 @@ function countComponents(n: number, edges: number[][]): number {
491491

492492
### Solution 3: BFS
493493

494+
We can also use BFS (Breadth-First Search) to count the number of connected components in the graph.
495+
496+
Similar to Solution 1, we first construct an adjacency list $g$ based on the given edges. Then we traverse all nodes. For each node, if it has not been visited, we start BFS traversal from this node, marking all its adjacent nodes as visited, until all its adjacent nodes have been visited. In this way, we have found a connected component, and the answer is incremented by one.
497+
498+
After traversing all nodes, we get the number of connected components in the graph.
499+
500+
The time complexity is $O(n + m)$, and the space complexity is $O(n + m)$. Where $n$ and $m$ are the number of nodes and edges, respectively.
501+
494502
<!-- tabs:start -->
495503

496-
#### TypeScript
504+
#### Python3
497505

498-
```ts
499-
function countComponents(n: number, edges: number[][]): number {
500-
const g: number[][] = Array.from({ length: n }, () => []);
501-
const vis = new Set<number>();
502-
let ans = 0;
506+
```python
507+
class Solution:
508+
def countComponents(self, n: int, edges: List[List[int]]) -> int:
509+
g = [[] for _ in range(n)]
510+
for a, b in edges:
511+
g[a].append(b)
512+
g[b].append(a)
513+
vis = set()
514+
ans = 0
515+
for i in range(n):
516+
if i in vis:
517+
continue
518+
vis.add(i)
519+
q = deque([i])
520+
while q:
521+
a = q.popleft()
522+
for b in g[a]:
523+
if b not in vis:
524+
vis.add(b)
525+
q.append(b)
526+
ans += 1
527+
return ans
528+
```
529+
530+
#### Java
503531

504-
for (const [i, j] of edges) {
505-
g[i].push(j);
506-
g[j].push(i);
532+
```java
533+
class Solution {
534+
public int countComponents(int n, int[][] edges) {
535+
List<Integer>[] g = new List[n];
536+
Arrays.setAll(g, k -> new ArrayList<>());
537+
for (var e : edges) {
538+
int a = e[0], b = e[1];
539+
g[a].add(b);
540+
g[b].add(a);
541+
}
542+
int ans = 0;
543+
boolean[] vis = new boolean[n];
544+
for (int i = 0; i < n; ++i) {
545+
if (vis[i]) {
546+
continue;
547+
}
548+
vis[i] = true;
549+
++ans;
550+
Deque<Integer> q = new ArrayDeque<>();
551+
q.offer(i);
552+
while (!q.isEmpty()) {
553+
int a = q.poll();
554+
for (int b : g[a]) {
555+
if (!vis[b]) {
556+
vis[b] = true;
557+
q.offer(b);
558+
}
559+
}
560+
}
561+
}
562+
return ans;
507563
}
564+
}
565+
```
508566

509-
const dfs = (i: number) => {
510-
if (vis.has(i)) return;
567+
#### C++
511568

512-
vis.add(i);
513-
for (const j of g[i]) {
514-
dfs(j);
569+
```cpp
570+
class Solution {
571+
public:
572+
int countComponents(int n, vector<vector<int>>& edges) {
573+
vector<int> g[n];
574+
for (auto& e : edges) {
575+
int a = e[0], b = e[1];
576+
g[a].push_back(b);
577+
g[b].push_back(a);
515578
}
516-
};
579+
vector<bool> vis(n);
580+
int ans = 0;
581+
for (int i = 0; i < n; ++i) {
582+
if (vis[i]) {
583+
continue;
584+
}
585+
vis[i] = true;
586+
++ans;
587+
queue<int> q{{i}};
588+
while (!q.empty()) {
589+
int a = q.front();
590+
q.pop();
591+
for (int b : g[a]) {
592+
if (!vis[b]) {
593+
vis[b] = true;
594+
q.push(b);
595+
}
596+
}
597+
}
598+
}
599+
return ans;
600+
}
601+
};
602+
```
517603
518-
for (let i = 0; i < n; i++) {
519-
if (vis.has(i)) continue;
604+
#### Go
520605
521-
dfs(i);
522-
ans++;
523-
}
606+
```go
607+
func countComponents(n int, edges [][]int) (ans int) {
608+
g := make([][]int, n)
609+
for _, e := range edges {
610+
a, b := e[0], e[1]
611+
g[a] = append(g[a], b)
612+
g[b] = append(g[b], a)
613+
}
614+
vis := make([]bool, n)
615+
for i := range g {
616+
if vis[i] {
617+
continue
618+
}
619+
vis[i] = true
620+
ans++
621+
q := []int{i}
622+
for len(q) > 0 {
623+
a := q[0]
624+
q = q[1:]
625+
for _, b := range g[a] {
626+
if !vis[b] {
627+
vis[b] = true
628+
q = append(q, b)
629+
}
630+
}
631+
}
632+
}
633+
return
634+
}
635+
```
636+
637+
#### TypeScript
524638

639+
```ts
640+
function countComponents(n: number, edges: number[][]): number {
641+
const g: number[][] = Array.from({ length: n }, () => []);
642+
for (const [a, b] of edges) {
643+
g[a].push(b);
644+
g[b].push(a);
645+
}
646+
const vis: boolean[] = Array(n).fill(false);
647+
let ans = 0;
648+
for (let i = 0; i < n; ++i) {
649+
if (vis[i]) {
650+
continue;
651+
}
652+
vis[i] = true;
653+
++ans;
654+
const q: number[] = [i];
655+
while (q.length) {
656+
const a = q.pop()!;
657+
for (const b of g[a]) {
658+
if (!vis[b]) {
659+
vis[b] = true;
660+
q.push(b);
661+
}
662+
}
663+
}
664+
}
525665
return ans;
526666
}
527667
```

0 commit comments

Comments
 (0)