Skip to content

Commit 03128fd

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1610
No.1610.Maximum Number of Visible Points
1 parent 2dcb5b3 commit 03128fd

File tree

6 files changed

+335
-4
lines changed

6 files changed

+335
-4
lines changed

‎solution/1600-1699/1610.Maximum Number of Visible Points/README.md

+120-2
Original file line numberDiff line numberDiff line change
@@ -57,27 +57,145 @@
5757
<li><code>0 <= pos<sub>x</sub>, pos<sub>y</sub>, x<sub>i</sub>, y<sub>i</sub> <= 100</code></li>
5858
</ul>
5959

60-
6160
## 解法
6261

6362
<!-- 这里可写通用的实现逻辑 -->
6463

64+
根据题目我们得知，需要求出在视角范围 `[d - angle/2, d + angle / 2]` 范围内覆盖的最多点的数量。视角可以转换为相对于 location `(x, y)` 的极角。
65+
66+
可以排除与 location 重合的点，将剩下的所有点 p 的坐标 `(xi, yi)` 转换为相对于 `(x, y)` 的极角。可以利用 `atan2` 函数，`atan2` 返回值范围是 `[−π,π]`，覆盖范围是 2π。
67+
68+
求出极角后，按照大小进行排序。因为可以循环，所以把整个数组所有元素加上 2π 接在数组后面。
69+
70+
接下来利用双指针找出覆盖最多点的区间即可。最后返回时，要把重合的点加上。
71+
6572
<!-- tabs:start -->
6673

6774
### **Python3**
6875

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

7178
```python
72-
79+
class Solution:
80+
def visiblePoints(self, points: List[List[int]], angle: int, location: List[int]) -> int:
81+
v = []
82+
x, y = location
83+
same = 0
84+
for xi, yi in points:
85+
if xi == x and yi == y:
86+
same += 1
87+
else:
88+
v.append(atan2(yi - y, xi - x))
89+
v.sort()
90+
n = len(v)
91+
v += [deg + 2 * pi for deg in v]
92+
t = angle * pi / 180
93+
mx = max((bisect_right(v, v[i] + t) - i for i in range(n)), default=0)
94+
return mx + same
7395
```
7496

7597
### **Java**
7698

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

79101
```java
102+
class Solution {
103+
public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
104+
List<Double> v = new ArrayList<>();
105+
int x = location.get(0), y = location.get(1);
106+
int same = 0;
107+
for (List<Integer> p : points) {
108+
int xi = p.get(0), yi = p.get(1);
109+
if (xi == x && yi == y) {
110+
++same;
111+
continue;
112+
}
113+
v.add(Math.atan2(yi - y, xi - x));
114+
}
115+
Collections.sort(v);
116+
int n = v.size();
117+
for (int i = 0; i < n; ++i) {
118+
v.add(v.get(i) + 2 * Math.PI);
119+
}
120+
int mx = 0;
121+
Double t = angle * Math.PI / 180;
122+
for (int i = 0, j = 0; j < 2 * n; ++j) {
123+
while (i < j && v.get(j) - v.get(i) > t) {
124+
++i;
125+
}
126+
mx = Math.max(mx, j - i + 1);
127+
}
128+
return mx + same;
129+
}
130+
}
131+
```
132+
133+
### **C++**
134+
135+
```cpp
136+
class Solution {
137+
public:
138+
int visiblePoints(vector<vector<int>>& points, int angle, vector<int>& location) {
139+
vector<double> v;
140+
int x = location[0], y = location[1];
141+
int same = 0;
142+
for (auto& p : points)
143+
{
144+
int xi = p[0], yi = p[1];
145+
if (xi == x && yi == y) ++same;
146+
else v.emplace_back(atan2(yi - y, xi - x));
147+
}
148+
sort(v.begin(), v.end());
149+
int n = v.size();
150+
for (int i = 0; i < n; ++i) v.emplace_back(v[i] + 2 * M_PI);
151+
152+
int mx = 0;
153+
double t = angle * M_PI / 180;
154+
for (int i = 0, j = 0; j < 2 * n; ++j)
155+
{
156+
while (i < j && v[j] - v[i] > t) ++i;
157+
mx = max(mx, j - i + 1);
158+
}
159+
return mx + same;
160+
}
161+
};
162+
```
80163

164+
### **Go**
165+
166+
```go
167+
func visiblePoints(points [][]int, angle int, location []int) int {
168+
same := 0
169+
v := []float64{}
170+
for _, p := range points {
171+
if p[0] == location[0] && p[1] == location[1] {
172+
same++
173+
} else {
174+
v = append(v, math.Atan2(float64(p[1]-location[1]), float64(p[0]-location[0])))
175+
}
176+
}
177+
sort.Float64s(v)
178+
for _, deg := range v {
179+
v = append(v, deg+2*math.Pi)
180+
}
181+
182+
mx := 0
183+
t := float64(angle) * math.Pi / 180
184+
for i, j := 0, 0; j < len(v); j++ {
185+
for i < j && v[j]-v[i] > t {
186+
i++
187+
}
188+
mx = max(mx, j-i+1)
189+
}
190+
return same + mx
191+
}
192+
193+
func max(a, b int) int {
194+
if a > b {
195+
return a
196+
}
197+
return b
198+
}
81199
```
82200

83201
### **...**

‎solution/1600-1699/1610.Maximum Number of Visible Points/README_EN.md

+112-2
Original file line numberDiff line numberDiff line change
@@ -54,21 +54,131 @@
5454
<li><code>0 &lt;= pos<sub>x</sub>, pos<sub>y</sub>, x<sub>i</sub>, y<sub>i</sub> &lt;= 100</code></li>
5555
</ul>
5656

57-
5857
## Solutions
5958

6059
<!-- tabs:start -->
6160

6261
### **Python3**
6362

6463
```python
65-
64+
class Solution:
65+
def visiblePoints(self, points: List[List[int]], angle: int, location: List[int]) -> int:
66+
v = []
67+
x, y = location
68+
same = 0
69+
for xi, yi in points:
70+
if xi == x and yi == y:
71+
same += 1
72+
else:
73+
v.append(atan2(yi - y, xi - x))
74+
v.sort()
75+
n = len(v)
76+
v += [deg + 2 * pi for deg in v]
77+
t = angle * pi / 180
78+
mx = max((bisect_right(v, v[i] + t) - i for i in range(n)), default=0)
79+
return mx + same
6680
```
6781

6882
### **Java**
6983

7084
```java
85+
class Solution {
86+
public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
87+
List<Double> v = new ArrayList<>();
88+
int x = location.get(0), y = location.get(1);
89+
int same = 0;
90+
for (List<Integer> p : points) {
91+
int xi = p.get(0), yi = p.get(1);
92+
if (xi == x && yi == y) {
93+
++same;
94+
continue;
95+
}
96+
v.add(Math.atan2(yi - y, xi - x));
97+
}
98+
Collections.sort(v);
99+
int n = v.size();
100+
for (int i = 0; i < n; ++i) {
101+
v.add(v.get(i) + 2 * Math.PI);
102+
}
103+
int mx = 0;
104+
Double t = angle * Math.PI / 180;
105+
for (int i = 0, j = 0; j < 2 * n; ++j) {
106+
while (i < j && v.get(j) - v.get(i) > t) {
107+
++i;
108+
}
109+
mx = Math.max(mx, j - i + 1);
110+
}
111+
return mx + same;
112+
}
113+
}
114+
```
115+
116+
### **C++**
117+
118+
```cpp
119+
class Solution {
120+
public:
121+
int visiblePoints(vector<vector<int>>& points, int angle, vector<int>& location) {
122+
vector<double> v;
123+
int x = location[0], y = location[1];
124+
int same = 0;
125+
for (auto& p : points)
126+
{
127+
int xi = p[0], yi = p[1];
128+
if (xi == x && yi == y) ++same;
129+
else v.emplace_back(atan2(yi - y, xi - x));
130+
}
131+
sort(v.begin(), v.end());
132+
int n = v.size();
133+
for (int i = 0; i < n; ++i) v.emplace_back(v[i] + 2 * M_PI);
134+
135+
int mx = 0;
136+
double t = angle * M_PI / 180;
137+
for (int i = 0, j = 0; j < 2 * n; ++j)
138+
{
139+
while (i < j && v[j] - v[i] > t) ++i;
140+
mx = max(mx, j - i + 1);
141+
}
142+
return mx + same;
143+
}
144+
};
145+
```
71146

147+
### **Go**
148+
149+
```go
150+
func visiblePoints(points [][]int, angle int, location []int) int {
151+
same := 0
152+
v := []float64{}
153+
for _, p := range points {
154+
if p[0] == location[0] && p[1] == location[1] {
155+
same++
156+
} else {
157+
v = append(v, math.Atan2(float64(p[1]-location[1]), float64(p[0]-location[0])))
158+
}
159+
}
160+
sort.Float64s(v)
161+
for _, deg := range v {
162+
v = append(v, deg+2*math.Pi)
163+
}
164+
165+
mx := 0
166+
t := float64(angle) * math.Pi / 180
167+
for i, j := 0, 0; j < len(v); j++ {
168+
for i < j && v[j]-v[i] > t {
169+
i++
170+
}
171+
mx = max(mx, j-i+1)
172+
}
173+
return same + mx
174+
}
175+
176+
func max(a, b int) int {
177+
if a > b {
178+
return a
179+
}
180+
return b
181+
}
72182
```
73183

74184
### **...**

‎solution/1600-1699/1610.Maximum Number of Visible Points/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int visiblePoints(vector<vector<int>>& points, int angle, vector<int>& location) {
4+
vector<double> v;
5+
int x = location[0], y = location[1];
6+
int same = 0;
7+
for (auto& p : points)
8+
{
9+
int xi = p[0], yi = p[1];
10+
if (xi == x && yi == y) ++same;
11+
else v.emplace_back(atan2(yi - y, xi - x));
12+
}
13+
sort(v.begin(), v.end());
14+
int n = v.size();
15+
for (int i = 0; i < n; ++i) v.emplace_back(v[i] + 2 * M_PI);
16+
17+
int mx = 0;
18+
double t = angle * M_PI / 180;
19+
for (int i = 0, j = 0; j < 2 * n; ++j)
20+
{
21+
while (i < j && v[j] - v[i] > t) ++i;
22+
mx = max(mx, j - i + 1);
23+
}
24+
return mx + same;
25+
}
26+
};

‎solution/1600-1699/1610.Maximum Number of Visible Points/Solution.go

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
func visiblePoints(points [][]int, angle int, location []int) int {
2+
same := 0
3+
v := []float64{}
4+
for _, p := range points {
5+
if p[0] == location[0] && p[1] == location[1] {
6+
same++
7+
} else {
8+
v = append(v, math.Atan2(float64(p[1]-location[1]), float64(p[0]-location[0])))
9+
}
10+
}
11+
sort.Float64s(v)
12+
for _, deg := range v {
13+
v = append(v, deg+2*math.Pi)
14+
}
15+
16+
mx := 0
17+
t := float64(angle) * math.Pi / 180
18+
for i, j := 0, 0; j < len(v); j++ {
19+
for i < j && v[j]-v[i] > t {
20+
i++
21+
}
22+
mx = max(mx, j-i+1)
23+
}
24+
return same + mx
25+
}
26+
27+
func max(a, b int) int {
28+
if a > b {
29+
return a
30+
}
31+
return b
32+
}

‎solution/1600-1699/1610.Maximum Number of Visible Points/Solution.java

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
3+
List<Double> v = new ArrayList<>();
4+
int x = location.get(0), y = location.get(1);
5+
int same = 0;
6+
for (List<Integer> p : points) {
7+
int xi = p.get(0), yi = p.get(1);
8+
if (xi == x && yi == y) {
9+
++same;
10+
continue;
11+
}
12+
v.add(Math.atan2(yi - y, xi - x));
13+
}
14+
Collections.sort(v);
15+
int n = v.size();
16+
for (int i = 0; i < n; ++i) {
17+
v.add(v.get(i) + 2 * Math.PI);
18+
}
19+
int mx = 0;
20+
Double t = angle * Math.PI / 180;
21+
for (int i = 0, j = 0; j < 2 * n; ++j) {
22+
while (i < j && v.get(j) - v.get(i) > t) {
23+
++i;
24+
}
25+
mx = Math.max(mx, j - i + 1);
26+
}
27+
return mx + same;
28+
}
29+
}

‎solution/1600-1699/1610.Maximum Number of Visible Points/Solution.py

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution:
2+
def visiblePoints(self, points: List[List[int]], angle: int, location: List[int]) -> int:
3+
v = []
4+
x, y = location
5+
same = 0
6+
for xi, yi in points:
7+
if xi == x and yi == y:
8+
same += 1
9+
else:
10+
v.append(atan2(yi - y, xi - x))
11+
v.sort()
12+
n = len(v)
13+
v += [deg + 2 * pi for deg in v]
14+
t = angle * pi / 180
15+
mx = max((bisect_right(v, v[i] + t) - i for i in range(n)), default=0)
16+
return mx + same

0 commit comments

Comments
 (0)