Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 92e6a5c

Browse files
feat: update solutions to lc problem: No.0841,0848 (doocs#2260)
1 parent 61017ae commit 92e6a5c

File tree

10 files changed

+188
-218
lines changed

10 files changed

+188
-218
lines changed

‎solution/0800-0899/0841.Keys and Rooms/README.md‎

Lines changed: 57 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -53,19 +53,25 @@
5353

5454
## 解法
5555

56-
### 方法一
56+
### 方法一:DFS
57+
58+
我们可以使用深度优先搜索的方法遍历整张图,统计可以到达的节点个数,并利用数组 `vis` 标记当前节点是否访问过,以防止重复访问。
59+
60+
最后统计访问过的节点个数,若与节点总数相同则说明可以访问所有节点,否则说明存在无法到达的节点。
61+
62+
时间复杂度 $O(n + m),ドル空间复杂度 $O(n),ドル其中 $n$ 为节点个数,而 $m$ 为边的个数。
5763

5864
<!-- tabs:start -->
5965

6066
```python
6167
class Solution:
6268
def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:
63-
def dfs(u):
64-
if u in vis:
69+
def dfs(i: int):
70+
if i in vis:
6571
return
66-
vis.add(u)
67-
for v in rooms[u]:
68-
dfs(v)
72+
vis.add(i)
73+
for j in rooms[i]:
74+
dfs(j)
6975

7076
vis = set()
7177
dfs(0)
@@ -74,23 +80,25 @@ class Solution:
7480

7581
```java
7682
class Solution {
77-
private List<List<Integer>> rooms;
78-
private Set<Integer> vis;
83+
private int cnt;
84+
private boolean[] vis;
85+
private List<List<Integer>> g;
7986

8087
public boolean canVisitAllRooms(List<List<Integer>> rooms) {
81-
vis = newHashSet<>();
82-
this.rooms = rooms;
88+
g = rooms;
89+
vis = newboolean[g.size()];
8390
dfs(0);
84-
return vis.size() == rooms.size();
91+
return cnt == g.size();
8592
}
8693

87-
private void dfs(int u) {
88-
if (vis.contains(u)) {
94+
private void dfs(int i) {
95+
if (vis[i]) {
8996
return;
9097
}
91-
vis.add(u);
92-
for (int v : rooms.get(u)) {
93-
dfs(v);
98+
vis[i] = true;
99+
++cnt;
100+
for (int j : g.get(i)) {
101+
dfs(j);
94102
}
95103
}
96104
}
@@ -99,55 +107,63 @@ class Solution {
99107
```cpp
100108
class Solution {
101109
public:
102-
vector<vector<int>> rooms;
103-
unordered_set<int> vis;
104-
105110
bool canVisitAllRooms(vector<vector<int>>& rooms) {
106-
vis.clear();
107-
this->rooms = rooms;
111+
int n = rooms.size();
112+
int cnt = 0;
113+
bool vis[n];
114+
memset(vis, false, sizeof(vis));
115+
function<void(int)> dfs = [&](int i) {
116+
if (vis[i]) {
117+
return;
118+
}
119+
vis[i] = true;
120+
++cnt;
121+
for (int j : rooms[i]) {
122+
dfs(j);
123+
}
124+
};
108125
dfs(0);
109-
return vis.size() == rooms.size();
110-
}
111-
112-
void dfs(int u) {
113-
if (vis.count(u)) return;
114-
vis.insert(u);
115-
for (int v : rooms[u]) dfs(v);
126+
return cnt == n;
116127
}
117128
};
118129
```
119130
120131
```go
121132
func canVisitAllRooms(rooms [][]int) bool {
122-
vis := make(map[int]bool)
123-
var dfs func(u int)
124-
dfs = func(u int) {
125-
if vis[u] {
133+
n := len(rooms)
134+
cnt := 0
135+
vis := make([]bool, n)
136+
var dfs func(int)
137+
dfs = func(i int) {
138+
if vis[i] {
126139
return
127140
}
128-
vis[u] = true
129-
for _, v := range rooms[u] {
130-
dfs(v)
141+
vis[i] = true
142+
cnt++
143+
for _, j := range rooms[i] {
144+
dfs(j)
131145
}
132146
}
133147
dfs(0)
134-
return len(vis) == len(rooms)
148+
return cnt == n
135149
}
136150
```
137151

138152
```ts
139153
function canVisitAllRooms(rooms: number[][]): boolean {
140154
const n = rooms.length;
141-
const isOpen =new Array(n).fill(false);
155+
const vis:boolean[] = Array(n).fill(false);
142156
const dfs = (i: number) => {
143-
if (isOpen[i]) {
157+
if (vis[i]) {
144158
return;
145159
}
146-
isOpen[i] = true;
147-
rooms[i].forEach(k => dfs(k));
160+
vis[i] = true;
161+
for (const j of rooms[i]) {
162+
dfs(j);
163+
}
148164
};
149165
dfs(0);
150-
return isOpen.every(v => v);
166+
return vis.every(v => v);
151167
}
152168
```
153169

@@ -172,27 +188,4 @@ impl Solution {
172188

173189
<!-- tabs:end -->
174190

175-
### 方法二
176-
177-
<!-- tabs:start -->
178-
179-
```ts
180-
function canVisitAllRooms(rooms: number[][]): boolean {
181-
const n = rooms.length;
182-
const isOpen = new Array(n).fill(false);
183-
const keys = [0];
184-
while (keys.length !== 0) {
185-
const i = keys.pop();
186-
if (isOpen[i]) {
187-
continue;
188-
}
189-
isOpen[i] = true;
190-
keys.push(...rooms[i]);
191-
}
192-
return isOpen.every(v => v);
193-
}
194-
```
195-
196-
<!-- tabs:end -->
197-
198191
<!-- end -->

‎solution/0800-0899/0841.Keys and Rooms/README_EN.md‎

Lines changed: 57 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -46,19 +46,25 @@ Since we were able to visit every room, we return true.
4646

4747
## Solutions
4848

49-
### Solution 1
49+
### Solution 1: Depth-First Search (DFS)
50+
51+
We can use the Depth-First Search (DFS) method to traverse the entire graph, count the number of reachable nodes, and use an array `vis` to mark whether the current node has been visited to prevent repeated visits.
52+
53+
Finally, we count the number of visited nodes. If it is the same as the total number of nodes, it means that all nodes can be visited; otherwise, there are nodes that cannot be reached.
54+
55+
The time complexity is $O(n + m),ドル and the space complexity is $O(n),ドル where $n$ is the number of nodes, and $m$ is the number of edges.
5056

5157
<!-- tabs:start -->
5258

5359
```python
5460
class Solution:
5561
def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:
56-
def dfs(u):
57-
if u in vis:
62+
def dfs(i: int):
63+
if i in vis:
5864
return
59-
vis.add(u)
60-
for v in rooms[u]:
61-
dfs(v)
65+
vis.add(i)
66+
for j in rooms[i]:
67+
dfs(j)
6268

6369
vis = set()
6470
dfs(0)
@@ -67,23 +73,25 @@ class Solution:
6773

6874
```java
6975
class Solution {
70-
private List<List<Integer>> rooms;
71-
private Set<Integer> vis;
76+
private int cnt;
77+
private boolean[] vis;
78+
private List<List<Integer>> g;
7279

7380
public boolean canVisitAllRooms(List<List<Integer>> rooms) {
74-
vis = newHashSet<>();
75-
this.rooms = rooms;
81+
g = rooms;
82+
vis = newboolean[g.size()];
7683
dfs(0);
77-
return vis.size() == rooms.size();
84+
return cnt == g.size();
7885
}
7986

80-
private void dfs(int u) {
81-
if (vis.contains(u)) {
87+
private void dfs(int i) {
88+
if (vis[i]) {
8289
return;
8390
}
84-
vis.add(u);
85-
for (int v : rooms.get(u)) {
86-
dfs(v);
91+
vis[i] = true;
92+
++cnt;
93+
for (int j : g.get(i)) {
94+
dfs(j);
8795
}
8896
}
8997
}
@@ -92,55 +100,63 @@ class Solution {
92100
```cpp
93101
class Solution {
94102
public:
95-
vector<vector<int>> rooms;
96-
unordered_set<int> vis;
97-
98103
bool canVisitAllRooms(vector<vector<int>>& rooms) {
99-
vis.clear();
100-
this->rooms = rooms;
104+
int n = rooms.size();
105+
int cnt = 0;
106+
bool vis[n];
107+
memset(vis, false, sizeof(vis));
108+
function<void(int)> dfs = [&](int i) {
109+
if (vis[i]) {
110+
return;
111+
}
112+
vis[i] = true;
113+
++cnt;
114+
for (int j : rooms[i]) {
115+
dfs(j);
116+
}
117+
};
101118
dfs(0);
102-
return vis.size() == rooms.size();
103-
}
104-
105-
void dfs(int u) {
106-
if (vis.count(u)) return;
107-
vis.insert(u);
108-
for (int v : rooms[u]) dfs(v);
119+
return cnt == n;
109120
}
110121
};
111122
```
112123
113124
```go
114125
func canVisitAllRooms(rooms [][]int) bool {
115-
vis := make(map[int]bool)
116-
var dfs func(u int)
117-
dfs = func(u int) {
118-
if vis[u] {
126+
n := len(rooms)
127+
cnt := 0
128+
vis := make([]bool, n)
129+
var dfs func(int)
130+
dfs = func(i int) {
131+
if vis[i] {
119132
return
120133
}
121-
vis[u] = true
122-
for _, v := range rooms[u] {
123-
dfs(v)
134+
vis[i] = true
135+
cnt++
136+
for _, j := range rooms[i] {
137+
dfs(j)
124138
}
125139
}
126140
dfs(0)
127-
return len(vis) == len(rooms)
141+
return cnt == n
128142
}
129143
```
130144

131145
```ts
132146
function canVisitAllRooms(rooms: number[][]): boolean {
133147
const n = rooms.length;
134-
const isOpen =new Array(n).fill(false);
148+
const vis:boolean[] = Array(n).fill(false);
135149
const dfs = (i: number) => {
136-
if (isOpen[i]) {
150+
if (vis[i]) {
137151
return;
138152
}
139-
isOpen[i] = true;
140-
rooms[i].forEach(k => dfs(k));
153+
vis[i] = true;
154+
for (const j of rooms[i]) {
155+
dfs(j);
156+
}
141157
};
142158
dfs(0);
143-
return isOpen.every(v => v);
159+
return vis.every(v => v);
144160
}
145161
```
146162

@@ -165,27 +181,4 @@ impl Solution {
165181

166182
<!-- tabs:end -->
167183

168-
### Solution 2
169-
170-
<!-- tabs:start -->
171-
172-
```ts
173-
function canVisitAllRooms(rooms: number[][]): boolean {
174-
const n = rooms.length;
175-
const isOpen = new Array(n).fill(false);
176-
const keys = [0];
177-
while (keys.length !== 0) {
178-
const i = keys.pop();
179-
if (isOpen[i]) {
180-
continue;
181-
}
182-
isOpen[i] = true;
183-
keys.push(...rooms[i]);
184-
}
185-
return isOpen.every(v => v);
186-
}
187-
```
188-
189-
<!-- tabs:end -->
190-
191184
<!-- end -->

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /