Skip to content

Commit 07557bb

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1954 (doocs#1251)
No.1954.Minimum Garden Perimeter to Collect Enough Apples
1 parent e4f7e15 commit 07557bb

File tree

7 files changed

+356
-0
lines changed

7 files changed

+356
-0
lines changed

‎solution/1900-1999/1954.Minimum Garden Perimeter to Collect Enough Apples/README.md

Lines changed: 161 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,22 +57,183 @@
5757

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

60+
**方法一：数学 + 枚举**
61+
62+
假设正方形右上角坐标为 $(n, n)$，那么它的边长为 $2n$，周长为 $8n$，里面的苹果总数为：
63+
64+
$$
65+
\begin{aligned}
66+
&\sum_{x=-n}^{n} \sum_{y=-n}^{n} |x| + |y| \\
67+
\end{aligned}
68+
$$
69+
70+
由于 $x$ 和 $y$ 是对称的，所以可以化简为：
71+
72+
$$
73+
\begin{aligned}
74+
&\sum_{x=-n}^{n} \sum_{y=-n}^{n} |x| + |y| \\
75+
&= 2 \sum_{x=-n}^{n} \sum_{y=-n}^{n} |x| \\
76+
&= 2 \sum_{x=-n}^{n} (2n + 1) |x| \\
77+
&= 2 (2n + 1) \sum_{x=-n}^{n} |x| \\
78+
&= 2n(n+1)(2n+1)
79+
\end{aligned}
80+
$$
81+
82+
所以，我们只需要枚举 $n$，直到找到第一个满足 $2n(n+1)(2n+1) \geq neededApples$ 的 $n$ 即可。
83+
84+
时间复杂度 $O(m^{\frac{1}{3}})$，其中 $m$ 为 $neededApples$ 的值。空间复杂度 $O(1)$。
85+
86+
**方法二：二分查找**
87+
88+
我们也可以二分枚举 $n$，时间复杂度 $O(\log m)$。
89+
6090
<!-- tabs:start -->
6191

6292
### **Python3**
6393

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

6696
```python
97+
class Solution:
98+
def minimumPerimeter(self, neededApples: int) -> int:
99+
x = 1
100+
while 2 * x * (x + 1) * (2 * x + 1) < neededApples:
101+
x += 1
102+
return x * 8
103+
```
67104

105+
```python
106+
class Solution:
107+
def minimumPerimeter(self, neededApples: int) -> int:
108+
l, r = 1, 100000
109+
while l < r:
110+
mid = (l + r) >> 1
111+
if 2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples:
112+
r = mid
113+
else:
114+
l = mid + 1
115+
return l * 8
68116
```
69117

70118
### **Java**
71119

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

74122
```java
123+
class Solution {
124+
public long minimumPerimeter(long neededApples) {
125+
long x = 1;
126+
while (2 * x * (x + 1) * (2 * x + 1) < neededApples) {
127+
++x;
128+
}
129+
return 8 * x;
130+
}
131+
}
132+
```
133+
134+
```java
135+
class Solution {
136+
public long minimumPerimeter(long neededApples) {
137+
long l = 1, r = 100000;
138+
while (l < r) {
139+
long mid = (l + r) >> 1;
140+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
141+
r = mid;
142+
} else {
143+
l = mid + 1;
144+
}
145+
}
146+
return l * 8;
147+
}
148+
}
149+
```
150+
151+
### **C++**
152+
153+
```cpp
154+
class Solution {
155+
public:
156+
long long minimumPerimeter(long long neededApples) {
157+
long long x = 1;
158+
while (2 * x * (x + 1) * (2 * x + 1) < neededApples) {
159+
++x;
160+
}
161+
return 8 * x;
162+
}
163+
};
164+
```
165+
166+
```cpp
167+
class Solution {
168+
public:
169+
long long minimumPerimeter(long long neededApples) {
170+
long long l = 1, r = 100000;
171+
while (l < r) {
172+
long mid = (l + r) >> 1;
173+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
174+
r = mid;
175+
} else {
176+
l = mid + 1;
177+
}
178+
}
179+
return l * 8;
180+
}
181+
};
182+
```
183+
184+
### **Go**
185+
186+
```go
187+
func minimumPerimeter(neededApples int64) int64 {
188+
var x int64 = 1
189+
for 2*x*(x+1)*(2*x+1) < neededApples {
190+
x++
191+
}
192+
return 8 * x
193+
}
194+
```
195+
196+
```go
197+
func minimumPerimeter(neededApples int64) int64 {
198+
var l, r int64 = 1, 100000
199+
for l < r {
200+
mid := (l + r) >> 1
201+
if 2*mid*(mid+1)*(2*mid+1) >= neededApples {
202+
r = mid
203+
} else {
204+
l = mid + 1
205+
}
206+
}
207+
return l * 8
208+
}
209+
```
210+
211+
### **TypeScript**
212+
213+
```ts
214+
function minimumPerimeter(neededApples: number): number {
215+
let x = 1;
216+
while (2 * x * (x + 1) * (2 * x + 1) < neededApples) {
217+
++x;
218+
}
219+
return 8 * x;
220+
}
221+
```
75222

223+
```ts
224+
function minimumPerimeter(neededApples: number): number {
225+
let l = 1;
226+
let r = 100000;
227+
while (l < r) {
228+
const mid = (l + r) >> 1;
229+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
230+
r = mid;
231+
} else {
232+
l = mid + 1;
233+
}
234+
}
235+
return 8 * l;
236+
}
76237
```
77238

78239
### **...**

‎solution/1900-1999/1954.Minimum Garden Perimeter to Collect Enough Apples/README_EN.md

Lines changed: 131 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,13 +56,144 @@ The perimeter is 2 * 4 = 8.
5656
### **Python3**
5757

5858
```python
59+
class Solution:
60+
def minimumPerimeter(self, neededApples: int) -> int:
61+
x = 1
62+
while 2 * x * (x + 1) * (2 * x + 1) < neededApples:
63+
x += 1
64+
return x * 8
65+
```
5966

67+
```python
68+
class Solution:
69+
def minimumPerimeter(self, neededApples: int) -> int:
70+
l, r = 1, 100000
71+
while l < r:
72+
mid = (l + r) >> 1
73+
if 2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples:
74+
r = mid
75+
else:
76+
l = mid + 1
77+
return l * 8
6078
```
6179

6280
### **Java**
6381

6482
```java
83+
class Solution {
84+
public long minimumPerimeter(long neededApples) {
85+
long x = 1;
86+
while (2 * x * (x + 1) * (2 * x + 1) < neededApples) {
87+
++x;
88+
}
89+
return 8 * x;
90+
}
91+
}
92+
```
93+
94+
```java
95+
class Solution {
96+
public long minimumPerimeter(long neededApples) {
97+
long l = 1, r = 100000;
98+
while (l < r) {
99+
long mid = (l + r) >> 1;
100+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
101+
r = mid;
102+
} else {
103+
l = mid + 1;
104+
}
105+
}
106+
return l * 8;
107+
}
108+
}
109+
```
110+
111+
### **C++**
112+
113+
```cpp
114+
class Solution {
115+
public:
116+
long long minimumPerimeter(long long neededApples) {
117+
long long x = 1;
118+
while (2 * x * (x + 1) * (2 * x + 1) < neededApples) {
119+
++x;
120+
}
121+
return 8 * x;
122+
}
123+
};
124+
```
125+
126+
```cpp
127+
class Solution {
128+
public:
129+
long long minimumPerimeter(long long neededApples) {
130+
long long l = 1, r = 100000;
131+
while (l < r) {
132+
long mid = (l + r) >> 1;
133+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
134+
r = mid;
135+
} else {
136+
l = mid + 1;
137+
}
138+
}
139+
return l * 8;
140+
}
141+
};
142+
```
143+
144+
### **Go**
145+
146+
```go
147+
func minimumPerimeter(neededApples int64) int64 {
148+
var x int64 = 1
149+
for 2*x*(x+1)*(2*x+1) < neededApples {
150+
x++
151+
}
152+
return 8 * x
153+
}
154+
```
155+
156+
```go
157+
func minimumPerimeter(neededApples int64) int64 {
158+
var l, r int64 = 1, 100000
159+
for l < r {
160+
mid := (l + r) >> 1
161+
if 2*mid*(mid+1)*(2*mid+1) >= neededApples {
162+
r = mid
163+
} else {
164+
l = mid + 1
165+
}
166+
}
167+
return l * 8
168+
}
169+
```
170+
171+
### **TypeScript**
172+
173+
```ts
174+
function minimumPerimeter(neededApples: number): number {
175+
let x = 1;
176+
while (2 * x * (x + 1) * (2 * x + 1) < neededApples) {
177+
++x;
178+
}
179+
return 8 * x;
180+
}
181+
```
65182

183+
```ts
184+
function minimumPerimeter(neededApples: number): number {
185+
let l = 1;
186+
let r = 100000;
187+
while (l < r) {
188+
const mid = (l + r) >> 1;
189+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
190+
r = mid;
191+
} else {
192+
l = mid + 1;
193+
}
194+
}
195+
return 8 * l;
196+
}
66197
```
67198

68199
### **...**

‎solution/1900-1999/1954.Minimum Garden Perimeter to Collect Enough Apples/Solution.cpp

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution {
2+
public:
3+
long long minimumPerimeter(long long neededApples) {
4+
long long l = 1, r = 100000;
5+
while (l < r) {
6+
long mid = (l + r) >> 1;
7+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
8+
r = mid;
9+
} else {
10+
l = mid + 1;
11+
}
12+
}
13+
return l * 8;
14+
}
15+
};

‎solution/1900-1999/1954.Minimum Garden Perimeter to Collect Enough Apples/Solution.go

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
func minimumPerimeter(neededApples int64) int64 {
2+
var l, r int64 = 1, 100000
3+
for l < r {
4+
mid := (l + r) >> 1
5+
if 2*mid*(mid+1)*(2*mid+1) >= neededApples {
6+
r = mid
7+
} else {
8+
l = mid + 1
9+
}
10+
}
11+
return l * 8
12+
}

‎solution/1900-1999/1954.Minimum Garden Perimeter to Collect Enough Apples/Solution.java

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public long minimumPerimeter(long neededApples) {
3+
long l = 1, r = 100000;
4+
while (l < r) {
5+
long mid = (l + r) >> 1;
6+
if (2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples) {
7+
r = mid;
8+
} else {
9+
l = mid + 1;
10+
}
11+
}
12+
return l * 8;
13+
}
14+
}

‎solution/1900-1999/1954.Minimum Garden Perimeter to Collect Enough Apples/Solution.py

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def minimumPerimeter(self, neededApples: int) -> int:
3+
l, r = 1, 100000
4+
while l < r:
5+
mid = (l + r) >> 1
6+
if 2 * mid * (mid + 1) * (2 * mid + 1) >= neededApples:
7+
r = mid
8+
else:
9+
l = mid + 1
10+
return l * 8

0 commit comments

Comments
 (0)