Skip to content

Commit 248c0a7

Browse files
CodersAcademy006CodersAcademy006
authored
feat: add solutions to lc problem: No.1453 (doocs#3395)
1 parent d6aa474 commit 248c0a7

File tree

3 files changed

+209
-5
lines changed

3 files changed

+209
-5
lines changed

‎solution/1400-1499/1453.Maximum Number of Darts Inside of a Circular Dartboard/README.md

+81-2
Original file line numberDiff line numberDiff line change
@@ -69,13 +69,92 @@ tags:
6969
#### Python3
7070

7171
```python
72-
72+
class Solution:
73+
def numPoints(self, darts: list[list[int]], r: int) -> int:
74+
def countDarts(x, y):
75+
count = 0
76+
for x1, y1 in darts:
77+
if dist((x, y), (x1, y1)) <= r + 1e-7:
78+
count += 1
79+
return count
80+
81+
def possibleCenters(x1, y1, x2, y2):
82+
dx, dy = x2 - x1, y2 - y1
83+
d = sqrt(dx * dx + dy * dy)
84+
if d > 2 * r:
85+
return []
86+
mid_x, mid_y = (x1 + x2) / 2, (y1 + y2) / 2
87+
dist_to_center = sqrt(r * r - (d / 2) * (d / 2))
88+
offset_x = dist_to_center * dy / d
89+
offset_y = dist_to_center * -dx / d
90+
return [
91+
(mid_x + offset_x, mid_y + offset_y),
92+
(mid_x - offset_x, mid_y - offset_y),
93+
]
94+
95+
n = len(darts)
96+
max_darts = 1
97+
98+
for i in range(n):
99+
for j in range(i + 1, n):
100+
centers = possibleCenters(
101+
darts[i][0], darts[i][1], darts[j][0], darts[j][1]
102+
)
103+
for center in centers:
104+
max_darts = max(max_darts, countDarts(center[0], center[1]))
105+
106+
return max_darts
73107
```
74108

75109
#### Java
76110

77111
```java
78-
112+
class Solution {
113+
public int numPoints(int[][] darts, int r) {
114+
int n = darts.length;
115+
int maxDarts = 1;
116+
117+
for (int i = 0; i < n; i++) {
118+
for (int j = i + 1; j < n; j++) {
119+
List<double[]> centers
120+
= possibleCenters(darts[i][0], darts[i][1], darts[j][0], darts[j][1], r);
121+
for (double[] center : centers) {
122+
maxDarts = Math.max(maxDarts, countDarts(center[0], center[1], darts, r));
123+
}
124+
}
125+
}
126+
return maxDarts;
127+
}
128+
129+
private List<double[]> possibleCenters(int x1, int y1, int x2, int y2, int r) {
130+
List<double[]> centers = new ArrayList<>();
131+
double dx = x2 - x1;
132+
double dy = y2 - y1;
133+
double d = Math.sqrt(dx * dx + dy * dy);
134+
if (d > 2 * r) {
135+
return centers;
136+
}
137+
double midX = (x1 + x2) / 2.0;
138+
double midY = (y1 + y2) / 2.0;
139+
double distToCenter = Math.sqrt(r * r - (d / 2.0) * (d / 2.0));
140+
double offsetX = distToCenter * dy / d;
141+
double offsetY = distToCenter * -dx / d;
142+
143+
centers.add(new double[] {midX + offsetX, midY + offsetY});
144+
centers.add(new double[] {midX - offsetX, midY - offsetY});
145+
return centers;
146+
}
147+
148+
private int countDarts(double x, double y, int[][] darts, int r) {
149+
int count = 0;
150+
for (int[] dart : darts) {
151+
if (Math.sqrt(Math.pow(dart[0] - x, 2) + Math.pow(dart[1] - y, 2)) <= r + 1e-7) {
152+
count++;
153+
}
154+
}
155+
return count;
156+
}
157+
}
79158
```
80159

81160
#### C++

‎solution/1400-1499/1453.Maximum Number of Darts Inside of a Circular Dartboard/README_EN.md

+82-3
Original file line numberDiff line numberDiff line change
@@ -60,20 +60,99 @@ tags:
6060

6161
<!-- solution:start -->
6262

63-
### Solution 1
63+
### 方法一
6464

6565
<!-- tabs:start -->
6666

6767
#### Python3
6868

6969
```python
70-
70+
class Solution:
71+
def numPoints(self, darts: list[list[int]], r: int) -> int:
72+
def countDarts(x, y):
73+
count = 0
74+
for x1, y1 in darts:
75+
if dist((x, y), (x1, y1)) <= r + 1e-7:
76+
count += 1
77+
return count
78+
79+
def possibleCenters(x1, y1, x2, y2):
80+
dx, dy = x2 - x1, y2 - y1
81+
d = sqrt(dx * dx + dy * dy)
82+
if d > 2 * r:
83+
return []
84+
mid_x, mid_y = (x1 + x2) / 2, (y1 + y2) / 2
85+
dist_to_center = sqrt(r * r - (d / 2) * (d / 2))
86+
offset_x = dist_to_center * dy / d
87+
offset_y = dist_to_center * -dx / d
88+
return [
89+
(mid_x + offset_x, mid_y + offset_y),
90+
(mid_x - offset_x, mid_y - offset_y),
91+
]
92+
93+
n = len(darts)
94+
max_darts = 1
95+
96+
for i in range(n):
97+
for j in range(i + 1, n):
98+
centers = possibleCenters(
99+
darts[i][0], darts[i][1], darts[j][0], darts[j][1]
100+
)
101+
for center in centers:
102+
max_darts = max(max_darts, countDarts(center[0], center[1]))
103+
104+
return max_darts
71105
```
72106

73107
#### Java
74108

75109
```java
76-
110+
class Solution {
111+
public int numPoints(int[][] darts, int r) {
112+
int n = darts.length;
113+
int maxDarts = 1;
114+
115+
for (int i = 0; i < n; i++) {
116+
for (int j = i + 1; j < n; j++) {
117+
List<double[]> centers
118+
= possibleCenters(darts[i][0], darts[i][1], darts[j][0], darts[j][1], r);
119+
for (double[] center : centers) {
120+
maxDarts = Math.max(maxDarts, countDarts(center[0], center[1], darts, r));
121+
}
122+
}
123+
}
124+
return maxDarts;
125+
}
126+
127+
private List<double[]> possibleCenters(int x1, int y1, int x2, int y2, int r) {
128+
List<double[]> centers = new ArrayList<>();
129+
double dx = x2 - x1;
130+
double dy = y2 - y1;
131+
double d = Math.sqrt(dx * dx + dy * dy);
132+
if (d > 2 * r) {
133+
return centers;
134+
}
135+
double midX = (x1 + x2) / 2.0;
136+
double midY = (y1 + y2) / 2.0;
137+
double distToCenter = Math.sqrt(r * r - (d / 2.0) * (d / 2.0));
138+
double offsetX = distToCenter * dy / d;
139+
double offsetY = distToCenter * -dx / d;
140+
141+
centers.add(new double[] {midX + offsetX, midY + offsetY});
142+
centers.add(new double[] {midX - offsetX, midY - offsetY});
143+
return centers;
144+
}
145+
146+
private int countDarts(double x, double y, int[][] darts, int r) {
147+
int count = 0;
148+
for (int[] dart : darts) {
149+
if (Math.sqrt(Math.pow(dart[0] - x, 2) + Math.pow(dart[1] - y, 2)) <= r + 1e-7) {
150+
count++;
151+
}
152+
}
153+
return count;
154+
}
155+
}
77156
```
78157

79158
#### C++

‎solution/1400-1499/1453.Maximum Number of Darts Inside of a Circular Dartboard/Solution.java

+46
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
class Solution {
2+
public int numPoints(int[][] darts, int r) {
3+
int n = darts.length;
4+
int maxDarts = 1;
5+
6+
for (int i = 0; i < n; i++) {
7+
for (int j = i + 1; j < n; j++) {
8+
List<double[]> centers
9+
= possibleCenters(darts[i][0], darts[i][1], darts[j][0], darts[j][1], r);
10+
for (double[] center : centers) {
11+
maxDarts = Math.max(maxDarts, countDarts(center[0], center[1], darts, r));
12+
}
13+
}
14+
}
15+
return maxDarts;
16+
}
17+
18+
private List<double[]> possibleCenters(int x1, int y1, int x2, int y2, int r) {
19+
List<double[]> centers = new ArrayList<>();
20+
double dx = x2 - x1;
21+
double dy = y2 - y1;
22+
double d = Math.sqrt(dx * dx + dy * dy);
23+
if (d > 2 * r) {
24+
return centers;
25+
}
26+
double midX = (x1 + x2) / 2.0;
27+
double midY = (y1 + y2) / 2.0;
28+
double distToCenter = Math.sqrt(r * r - (d / 2.0) * (d / 2.0));
29+
double offsetX = distToCenter * dy / d;
30+
double offsetY = distToCenter * -dx / d;
31+
32+
centers.add(new double[] {midX + offsetX, midY + offsetY});
33+
centers.add(new double[] {midX - offsetX, midY - offsetY});
34+
return centers;
35+
}
36+
37+
private int countDarts(double x, double y, int[][] darts, int r) {
38+
int count = 0;
39+
for (int[] dart : darts) {
40+
if (Math.sqrt(Math.pow(dart[0] - x, 2) + Math.pow(dart[1] - y, 2)) <= r + 1e-7) {
41+
count++;
42+
}
43+
}
44+
return count;
45+
}
46+
}

0 commit comments

Comments
 (0)