Skip to content

Commit c7293b9

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2753 (doocs#1154)
No.2753.Count Houses in a Circular Street II
1 parent 931af36 commit c7293b9

File tree

8 files changed

+366
-6
lines changed

8 files changed

+366
-6
lines changed

‎solution/2700-2799/2728.Count Houses in a Circular Street/README.md

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,10 @@
6161

6262
时间复杂度 $O(k)$，其中 $k$ 为题目给定的整数。空间复杂度 $O(1)$。
6363

64+
相似题目：
65+
66+
- [2753. 计算一个环形街道上的房屋数量 II](/solution/2700-2799/2753.Count%20Houses%20in%20a%20Circular%20Street%20II/README.md)
67+
6468
<!-- tabs:start -->
6569

6670
### **Python3**

‎solution/2700-2799/2753.Count Houses in a Circular Street II/README.md

Lines changed: 130 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -56,34 +56,161 @@
5656

5757
<!-- 这里可写通用的实现逻辑 -->
5858

59+
**方法一：脑筋急转弯**
60+
61+
我们注意到，题目中至少有一扇门是开着的，我们可以先找到其中一扇开着的门。
62+
63+
然后，我们跳过这扇开着的门，往右移动，每次移动时，计数器加一，如果遇到开着的门，就把门关上。那么答案就是最后一次遇到的开着的门时的计数器的值。
64+
65+
时间复杂度 $O(k)$，空间复杂度 $O(1)$。
66+
67+
相似题目：
68+
69+
- [2728. 计算一个环形街道上的房屋数量](/solution/2700-2799/2728.Count%20Houses%20in%20a%20Circular%20Street/README.md)
70+
5971
<!-- tabs:start -->
6072

6173
### **Python3**
6274

6375
<!-- 这里可写当前语言的特殊实现逻辑 -->
6476

6577
```python
66-
78+
# Definition for a street.
79+
# class Street:
80+
# def closeDoor(self):
81+
# pass
82+
# def isDoorOpen(self):
83+
# pass
84+
# def moveRight(self):
85+
# pass
86+
class Solution:
87+
def houseCount(self, street: Optional["Street"], k: int) -> int:
88+
while not street.isDoorOpen():
89+
street.moveRight()
90+
for i in range(1, k + 1):
91+
street.moveRight()
92+
if street.isDoorOpen():
93+
ans = i
94+
street.closeDoor()
95+
return ans
6796
```
6897

6998
### **Java**
7099

71100
<!-- 这里可写当前语言的特殊实现逻辑 -->
72101

73102
```java
74-
103+
/**
104+
* Definition for a street.
105+
* class Street {
106+
* public Street(int[] doors);
107+
* public void closeDoor();
108+
* public boolean isDoorOpen();
109+
* public void moveRight();
110+
* }
111+
*/
112+
class Solution {
113+
public int houseCount(Street street, int k) {
114+
while (!street.isDoorOpen()) {
115+
street.moveRight();
116+
}
117+
int ans = 0;
118+
for (int i = 1; i <= k; ++i) {
119+
street.moveRight();
120+
if (street.isDoorOpen()) {
121+
ans = i;
122+
street.closeDoor();
123+
}
124+
}
125+
return ans;
126+
}
127+
}
75128
```
76129

77130
### **C++**
78131

79132
```cpp
80-
133+
/**
134+
* Definition for a street.
135+
* class Street {
136+
* public:
137+
* Street(vector<int> doors);
138+
* void closeDoor();
139+
* bool isDoorOpen();
140+
* void moveRight();
141+
* };
142+
*/
143+
class Solution {
144+
public:
145+
int houseCount(Street* street, int k) {
146+
while (!street->isDoorOpen()) {
147+
street->moveRight();
148+
}
149+
int ans = 0;
150+
for (int i = 1; i <= k; ++i) {
151+
street->moveRight();
152+
if (street->isDoorOpen()) {
153+
ans = i;
154+
street->closeDoor();
155+
}
156+
}
157+
return ans;
158+
}
159+
};
81160
```
82161
83162
### **Go**
84163
85164
```go
165+
/**
166+
* Definition for a street.
167+
* type Street interface {
168+
* CloseDoor()
169+
* IsDoorOpen() bool
170+
* MoveRight()
171+
* }
172+
*/
173+
func houseCount(street Street, k int) (ans int) {
174+
for !street.IsDoorOpen() {
175+
street.MoveRight()
176+
}
177+
for i := 1; i <= k; i++ {
178+
street.MoveRight()
179+
if street.IsDoorOpen() {
180+
ans = i
181+
street.CloseDoor()
182+
}
183+
}
184+
return
185+
}
186+
```
86187

188+
### **TypeScript**
189+
190+
```ts
191+
/**
192+
* Definition for a street.
193+
* class Street {
194+
* constructor(doors: number[]);
195+
* public closeDoor(): void;
196+
* public isDoorOpen(): boolean;
197+
* public moveRight(): void;
198+
* }
199+
*/
200+
function houseCount(street: Street | null, k: number): number {
201+
while (!street.isDoorOpen()) {
202+
street.moveRight();
203+
}
204+
let ans = 0;
205+
for (let i = 1; i <= k; ++i) {
206+
street.moveRight();
207+
if (street.isDoorOpen()) {
208+
ans = i;
209+
street.closeDoor();
210+
}
211+
}
212+
return ans;
213+
}
87214
```
88215

89216
### **...**

‎solution/2700-2799/2753.Count Houses in a Circular Street II/README_EN.md

Lines changed: 118 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -55,25 +55,140 @@ The number of houses is equal to k, which is 5.
5555
### **Python3**
5656

5757
```python
58-
58+
# Definition for a street.
59+
# class Street:
60+
# def closeDoor(self):
61+
# pass
62+
# def isDoorOpen(self):
63+
# pass
64+
# def moveRight(self):
65+
# pass
66+
class Solution:
67+
def houseCount(self, street: Optional["Street"], k: int) -> int:
68+
while not street.isDoorOpen():
69+
street.moveRight()
70+
for i in range(1, k + 1):
71+
street.moveRight()
72+
if street.isDoorOpen():
73+
ans = i
74+
street.closeDoor()
75+
return ans
5976
```
6077

6178
### **Java**
6279

6380
```java
64-
81+
/**
82+
* Definition for a street.
83+
* class Street {
84+
* public Street(int[] doors);
85+
* public void closeDoor();
86+
* public boolean isDoorOpen();
87+
* public void moveRight();
88+
* }
89+
*/
90+
class Solution {
91+
public int houseCount(Street street, int k) {
92+
while (!street.isDoorOpen()) {
93+
street.moveRight();
94+
}
95+
int ans = 0;
96+
for (int i = 1; i <= k; ++i) {
97+
street.moveRight();
98+
if (street.isDoorOpen()) {
99+
ans = i;
100+
street.closeDoor();
101+
}
102+
}
103+
return ans;
104+
}
105+
}
65106
```
66107

67108
### **C++**
68109

69110
```cpp
70-
111+
/**
112+
* Definition for a street.
113+
* class Street {
114+
* public:
115+
* Street(vector<int> doors);
116+
* void closeDoor();
117+
* bool isDoorOpen();
118+
* void moveRight();
119+
* };
120+
*/
121+
class Solution {
122+
public:
123+
int houseCount(Street* street, int k) {
124+
while (!street->isDoorOpen()) {
125+
street->moveRight();
126+
}
127+
int ans = 0;
128+
for (int i = 1; i <= k; ++i) {
129+
street->moveRight();
130+
if (street->isDoorOpen()) {
131+
ans = i;
132+
street->closeDoor();
133+
}
134+
}
135+
return ans;
136+
}
137+
};
71138
```
72139
73140
### **Go**
74141
75142
```go
143+
/**
144+
* Definition for a street.
145+
* type Street interface {
146+
* CloseDoor()
147+
* IsDoorOpen() bool
148+
* MoveRight()
149+
* }
150+
*/
151+
func houseCount(street Street, k int) (ans int) {
152+
for !street.IsDoorOpen() {
153+
street.MoveRight()
154+
}
155+
for i := 1; i <= k; i++ {
156+
street.MoveRight()
157+
if street.IsDoorOpen() {
158+
ans = i
159+
street.CloseDoor()
160+
}
161+
}
162+
return
163+
}
164+
```
76165

166+
### **TypeScript**
167+
168+
```ts
169+
/**
170+
* Definition for a street.
171+
* class Street {
172+
* constructor(doors: number[]);
173+
* public closeDoor(): void;
174+
* public isDoorOpen(): boolean;
175+
* public moveRight(): void;
176+
* }
177+
*/
178+
function houseCount(street: Street | null, k: number): number {
179+
while (!street.isDoorOpen()) {
180+
street.moveRight();
181+
}
182+
let ans = 0;
183+
for (let i = 1; i <= k; ++i) {
184+
street.moveRight();
185+
if (street.isDoorOpen()) {
186+
ans = i;
187+
street.closeDoor();
188+
}
189+
}
190+
return ans;
191+
}
77192
```
78193

79194
### **...**

‎solution/2700-2799/2753.Count Houses in a Circular Street II/Solution.cpp

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
/**
2+
* Definition for a street.
3+
* class Street {
4+
* public:
5+
* Street(vector<int> doors);
6+
* void closeDoor();
7+
* bool isDoorOpen();
8+
* void moveRight();
9+
* };
10+
*/
11+
class Solution {
12+
public:
13+
int houseCount(Street* street, int k) {
14+
while (!street->isDoorOpen()) {
15+
street->moveRight();
16+
}
17+
int ans = 0;
18+
for (int i = 1; i <= k; ++i) {
19+
street->moveRight();
20+
if (street->isDoorOpen()) {
21+
ans = i;
22+
street->closeDoor();
23+
}
24+
}
25+
return ans;
26+
}
27+
};

‎solution/2700-2799/2753.Count Houses in a Circular Street II/Solution.go

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
/**
2+
* Definition for a street.
3+
* type Street interface {
4+
* CloseDoor()
5+
* IsDoorOpen() bool
6+
* MoveRight()
7+
* }
8+
*/
9+
func houseCount(street Street, k int) (ans int) {
10+
for !street.IsDoorOpen() {
11+
street.MoveRight()
12+
}
13+
for i := 1; i <= k; i++ {
14+
street.MoveRight()
15+
if street.IsDoorOpen() {
16+
ans = i
17+
street.CloseDoor()
18+
}
19+
}
20+
return
21+
}

‎solution/2700-2799/2753.Count Houses in a Circular Street II/Solution.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* Definition for a street.
3+
* class Street {
4+
* public Street(int[] doors);
5+
* public void closeDoor();
6+
* public boolean isDoorOpen();
7+
* public void moveRight();
8+
* }
9+
*/
10+
class Solution {
11+
public int houseCount(Street street, int k) {
12+
while (!street.isDoorOpen()) {
13+
street.moveRight();
14+
}
15+
int ans = 0;
16+
for (int i = 1; i <= k; ++i) {
17+
street.moveRight();
18+
if (street.isDoorOpen()) {
19+
ans = i;
20+
street.closeDoor();
21+
}
22+
}
23+
return ans;
24+
}
25+
}

0 commit comments

Comments
 (0)