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 f1585d4

Browse files
feat: add solutions to lc problems: No.1515,1654 (doocs#1543)
* No.1515.Best Position for a Service Centre * No.1654.Minimum Jumps to Reach Home
1 parent 2238f29 commit f1585d4

File tree

13 files changed

+697
-90
lines changed

13 files changed

+697
-90
lines changed

‎solution/1500-1599/1515.Best Position for a Service Centre/README.md‎

Lines changed: 179 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,200 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一:梯度下降法**
56+
57+
我们可以先设定一个初始的服务中心位置为所有客户坐标的几何中心 $(x, y)$。接下来,使用梯度下降法不断迭代,设定一个学习率 $\alpha=0.5,ドル衰减率 $decay=0.999$。每次一次迭代,计算当前位置到所有客户的距离之和,然后计算当前位置的梯度,最后更新当前位置。当梯度的绝对值都小于 10ドル^{-6}$ 时,停止迭代,返回当前位置到所有客户的距离之和。
58+
5559
<!-- tabs:start -->
5660

5761
### **Python3**
5862

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

6165
```python
62-
66+
class Solution:
67+
def getMinDistSum(self, positions: List[List[int]]) -> float:
68+
n = len(positions)
69+
x = y = 0
70+
for x1, y1 in positions:
71+
x += x1
72+
y += y1
73+
x, y = x / n, y / n
74+
decay = 0.999
75+
eps = 1e-6
76+
alpha = 0.5
77+
while 1:
78+
grad_x = grad_y = 0
79+
dist = 0
80+
for x1, y1 in positions:
81+
a = x - x1
82+
b = y - y1
83+
c = sqrt(a * a + b * b)
84+
grad_x += a / (c + 1e-8)
85+
grad_y += b / (c + 1e-8)
86+
dist += c
87+
dx = grad_x * alpha
88+
dy = grad_y * alpha
89+
x -= dx
90+
y -= dy
91+
alpha *= decay
92+
if abs(dx) <= eps and abs(dy) <= eps:
93+
return dist
6394
```
6495

6596
### **Java**
6697

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

69100
```java
101+
class Solution {
102+
public double getMinDistSum(int[][] positions) {
103+
int n = positions.length;
104+
double x = 0, y = 0;
105+
for (int[] p : positions) {
106+
x += p[0];
107+
y += p[1];
108+
}
109+
x /= n;
110+
y /= n;
111+
double decay = 0.999;
112+
double eps = 1e-6;
113+
double alpha = 0.5;
114+
while (true) {
115+
double gradX = 0, gradY = 0;
116+
double dist = 0;
117+
for (int[] p : positions) {
118+
double a = x - p[0], b = y - p[1];
119+
double c = Math.sqrt(a * a + b * b);
120+
gradX += a / (c + 1e-8);
121+
gradY += b / (c + 1e-8);
122+
dist += c;
123+
}
124+
double dx = gradX * alpha, dy = gradY * alpha;
125+
if (Math.abs(dx) <= eps && Math.abs(dy) <= eps) {
126+
return dist;
127+
}
128+
x -= dx;
129+
y -= dy;
130+
alpha *= decay;
131+
}
132+
}
133+
}
134+
```
135+
136+
### **C++**
137+
138+
```cpp
139+
class Solution {
140+
public:
141+
double getMinDistSum(vector<vector<int>>& positions) {
142+
int n = positions.size();
143+
double x = 0, y = 0;
144+
for (auto& p : positions) {
145+
x += p[0];
146+
y += p[1];
147+
}
148+
x /= n;
149+
y /= n;
150+
double decay = 0.999;
151+
double eps = 1e-6;
152+
double alpha = 0.5;
153+
while (true) {
154+
double gradX = 0, gradY = 0;
155+
double dist = 0;
156+
for (auto& p : positions) {
157+
double a = x - p[0], b = y - p[1];
158+
double c = sqrt(a * a + b * b);
159+
gradX += a / (c + 1e-8);
160+
gradY += b / (c + 1e-8);
161+
dist += c;
162+
}
163+
double dx = gradX * alpha, dy = gradY * alpha;
164+
if (abs(dx) <= eps && abs(dy) <= eps) {
165+
return dist;
166+
}
167+
x -= dx;
168+
y -= dy;
169+
alpha *= decay;
170+
}
171+
}
172+
};
173+
```
174+
175+
### **Go**
176+
177+
```go
178+
func getMinDistSum(positions [][]int) float64 {
179+
n := len(positions)
180+
var x, y float64
181+
for _, p := range positions {
182+
x += float64(p[0])
183+
y += float64(p[1])
184+
}
185+
x /= float64(n)
186+
y /= float64(n)
187+
const decay float64 = 0.999
188+
const eps float64 = 1e-6
189+
var alpha float64 = 0.5
190+
for {
191+
var gradX, gradY float64
192+
var dist float64
193+
for _, p := range positions {
194+
a := x - float64(p[0])
195+
b := y - float64(p[1])
196+
c := math.Sqrt(a*a + b*b)
197+
gradX += a / (c + 1e-8)
198+
gradY += b / (c + 1e-8)
199+
dist += c
200+
}
201+
dx := gradX * alpha
202+
dy := gradY * alpha
203+
if math.Abs(dx) <= eps && math.Abs(dy) <= eps {
204+
return dist
205+
}
206+
x -= dx
207+
y -= dy
208+
alpha *= decay
209+
}
210+
}
211+
```
70212

213+
### **TypeScript**
214+
215+
```ts
216+
function getMinDistSum(positions: number[][]): number {
217+
const n = positions.length;
218+
let [x, y] = [0, 0];
219+
for (const [px, py] of positions) {
220+
x += px;
221+
y += py;
222+
}
223+
x /= n;
224+
y /= n;
225+
const decay = 0.999;
226+
const eps = 1e-6;
227+
let alpha = 0.5;
228+
while (true) {
229+
let [gradX, gradY] = [0, 0];
230+
let dist = 0;
231+
for (const [px, py] of positions) {
232+
const a = x - px;
233+
const b = y - py;
234+
const c = Math.sqrt(a * a + b * b);
235+
gradX += a / (c + 1e-8);
236+
gradY += b / (c + 1e-8);
237+
dist += c;
238+
}
239+
const dx = gradX * alpha;
240+
const dy = gradY * alpha;
241+
if (Math.abs(dx) <= eps && Math.abs(dy) <= eps) {
242+
return dist;
243+
}
244+
x -= dx;
245+
y -= dy;
246+
alpha *= decay;
247+
}
248+
}
71249
```
72250

73251
### **...**

‎solution/1500-1599/1515.Best Position for a Service Centre/README_EN.md‎

Lines changed: 175 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,13 +45,187 @@
4545
### **Python3**
4646

4747
```python
48-
48+
class Solution:
49+
def getMinDistSum(self, positions: List[List[int]]) -> float:
50+
n = len(positions)
51+
x = y = 0
52+
for x1, y1 in positions:
53+
x += x1
54+
y += y1
55+
x, y = x / n, y / n
56+
decay = 0.999
57+
eps = 1e-6
58+
alpha = 0.5
59+
while 1:
60+
grad_x = grad_y = 0
61+
dist = 0
62+
for x1, y1 in positions:
63+
a = x - x1
64+
b = y - y1
65+
c = sqrt(a * a + b * b)
66+
grad_x += a / (c + 1e-8)
67+
grad_y += b / (c + 1e-8)
68+
dist += c
69+
dx = grad_x * alpha
70+
dy = grad_y * alpha
71+
x -= dx
72+
y -= dy
73+
alpha *= decay
74+
if abs(dx) <= eps and abs(dy) <= eps:
75+
return dist
4976
```
5077

5178
### **Java**
5279

5380
```java
81+
class Solution {
82+
public double getMinDistSum(int[][] positions) {
83+
int n = positions.length;
84+
double x = 0, y = 0;
85+
for (int[] p : positions) {
86+
x += p[0];
87+
y += p[1];
88+
}
89+
x /= n;
90+
y /= n;
91+
double decay = 0.999;
92+
double eps = 1e-6;
93+
double alpha = 0.5;
94+
while (true) {
95+
double gradX = 0, gradY = 0;
96+
double dist = 0;
97+
for (int[] p : positions) {
98+
double a = x - p[0], b = y - p[1];
99+
double c = Math.sqrt(a * a + b * b);
100+
gradX += a / (c + 1e-8);
101+
gradY += b / (c + 1e-8);
102+
dist += c;
103+
}
104+
double dx = gradX * alpha, dy = gradY * alpha;
105+
if (Math.abs(dx) <= eps && Math.abs(dy) <= eps) {
106+
return dist;
107+
}
108+
x -= dx;
109+
y -= dy;
110+
alpha *= decay;
111+
}
112+
}
113+
}
114+
```
115+
116+
### **C++**
117+
118+
```cpp
119+
class Solution {
120+
public:
121+
double getMinDistSum(vector<vector<int>>& positions) {
122+
int n = positions.size();
123+
double x = 0, y = 0;
124+
for (auto& p : positions) {
125+
x += p[0];
126+
y += p[1];
127+
}
128+
x /= n;
129+
y /= n;
130+
double decay = 0.999;
131+
double eps = 1e-6;
132+
double alpha = 0.5;
133+
while (true) {
134+
double gradX = 0, gradY = 0;
135+
double dist = 0;
136+
for (auto& p : positions) {
137+
double a = x - p[0], b = y - p[1];
138+
double c = sqrt(a * a + b * b);
139+
gradX += a / (c + 1e-8);
140+
gradY += b / (c + 1e-8);
141+
dist += c;
142+
}
143+
double dx = gradX * alpha, dy = gradY * alpha;
144+
if (abs(dx) <= eps && abs(dy) <= eps) {
145+
return dist;
146+
}
147+
x -= dx;
148+
y -= dy;
149+
alpha *= decay;
150+
}
151+
}
152+
};
153+
```
154+
155+
### **Go**
156+
157+
```go
158+
func getMinDistSum(positions [][]int) float64 {
159+
n := len(positions)
160+
var x, y float64
161+
for _, p := range positions {
162+
x += float64(p[0])
163+
y += float64(p[1])
164+
}
165+
x /= float64(n)
166+
y /= float64(n)
167+
const decay float64 = 0.999
168+
const eps float64 = 1e-6
169+
var alpha float64 = 0.5
170+
for {
171+
var gradX, gradY float64
172+
var dist float64
173+
for _, p := range positions {
174+
a := x - float64(p[0])
175+
b := y - float64(p[1])
176+
c := math.Sqrt(a*a + b*b)
177+
gradX += a / (c + 1e-8)
178+
gradY += b / (c + 1e-8)
179+
dist += c
180+
}
181+
dx := gradX * alpha
182+
dy := gradY * alpha
183+
if math.Abs(dx) <= eps && math.Abs(dy) <= eps {
184+
return dist
185+
}
186+
x -= dx
187+
y -= dy
188+
alpha *= decay
189+
}
190+
}
191+
```
54192

193+
### **TypeScript**
194+
195+
```ts
196+
function getMinDistSum(positions: number[][]): number {
197+
const n = positions.length;
198+
let [x, y] = [0, 0];
199+
for (const [px, py] of positions) {
200+
x += px;
201+
y += py;
202+
}
203+
x /= n;
204+
y /= n;
205+
const decay = 0.999;
206+
const eps = 1e-6;
207+
let alpha = 0.5;
208+
while (true) {
209+
let [gradX, gradY] = [0, 0];
210+
let dist = 0;
211+
for (const [px, py] of positions) {
212+
const a = x - px;
213+
const b = y - py;
214+
const c = Math.sqrt(a * a + b * b);
215+
gradX += a / (c + 1e-8);
216+
gradY += b / (c + 1e-8);
217+
dist += c;
218+
}
219+
const dx = gradX * alpha;
220+
const dy = gradY * alpha;
221+
if (Math.abs(dx) <= eps && Math.abs(dy) <= eps) {
222+
return dist;
223+
}
224+
x -= dx;
225+
y -= dy;
226+
alpha *= decay;
227+
}
228+
}
55229
```
56230

57231
### **...**

0 commit comments

Comments
(0)

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