Skip to content

Commit 6b910be

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2345
No.2345.Finding the Number of Visible Mountains
1 parent 8e60613 commit 6b910be

File tree

6 files changed

+331
-2
lines changed

6 files changed

+331
-2
lines changed

‎solution/2300-2399/2345.Finding the Number of Visible Mountains/README.md

+129-1
Original file line numberDiff line numberDiff line change
@@ -48,22 +48,150 @@
4848

4949
<!-- 这里可写通用的实现逻辑 -->
5050

51+
**方法一：区间排序 + 遍历**
52+
53+
我们先将每座山 $(x, y)$ 转换成横坐标的区间 $(x - y, x + y)$，然后对区间按照左端点升序排序，右端点降序排序。
54+
55+
接下来，初始化当前区间的右端点为 $-\infty$，遍历每座山，如果当前山的右端点小于等于当前区间的右端点，则跳过该山，否则更新当前区间的右端点为当前山的右端点，如果当前山的区间只出现一次，则答案加一。
56+
57+
遍历结束后返回答案即可。
58+
59+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为山的数量。
60+
5161
<!-- tabs:start -->
5262

5363
### **Python3**
5464

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

5767
```python
58-
68+
class Solution:
69+
def visibleMountains(self, peaks: List[List[int]]) -> int:
70+
arr = [(x - y, x + y) for x, y in peaks]
71+
cnt = Counter(arr)
72+
arr.sort(key=lambda x: (x[0], -x[1]))
73+
ans, cur = 0, -inf
74+
for l, r in arr:
75+
if r <= cur:
76+
continue
77+
cur = r
78+
if cnt[(l, r)] == 1:
79+
ans += 1
80+
return ans
5981
```
6082

6183
### **Java**
6284

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

6587
```java
88+
class Solution {
89+
public int visibleMountains(int[][] peaks) {
90+
int n = peaks.length;
91+
int[][] arr = new int[n][2];
92+
Map<String, Integer> cnt = new HashMap<>();
93+
for (int i = 0; i < n; ++i) {
94+
int x = peaks[i][0], y = peaks[i][1];
95+
arr[i] = new int[] {x - y, x + y};
96+
cnt.merge((x - y) + "" + (x + y), 1, Integer::sum);
97+
}
98+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
99+
int ans = 0;
100+
int cur = Integer.MIN_VALUE;
101+
for (int[] e : arr) {
102+
int l = e[0], r = e[1];
103+
if (r <= cur) {
104+
continue;
105+
}
106+
cur = r;
107+
if (cnt.get(l + "" + r) == 1) {
108+
++ans;
109+
}
110+
}
111+
return ans;
112+
}
113+
}
114+
```
115+
116+
```java
117+
class Solution {
118+
public int visibleMountains(int[][] peaks) {
119+
int n = peaks.length;
120+
int[][] arr = new int[n][2];
121+
for (int i = 0; i < n; ++i) {
122+
int x = peaks[i][0], y = peaks[i][1];
123+
arr[i] = new int[] {x - y, x + y};
124+
}
125+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
126+
int ans = 0;
127+
int cur = Integer.MIN_VALUE;
128+
for (int i = 0; i < n; ++i) {
129+
int l = arr[i][0], r = arr[i][1];
130+
if (r <= cur) {
131+
continue;
132+
}
133+
cur = r;
134+
if (!(i < n - 1 && arr[i][0] == arr[i + 1][0] && arr[i][1] == arr[i + 1][1])) {
135+
++ans;
136+
}
137+
}
138+
return ans;
139+
}
140+
}
141+
```
142+
143+
### **C++**
144+
145+
```cpp
146+
class Solution {
147+
public:
148+
int visibleMountains(vector<vector<int>>& peaks) {
149+
vector<pair<int, int>> arr;
150+
for (auto& e : peaks) {
151+
int x = e[0], y = e[1];
152+
arr.emplace_back(x - y, -(x + y));
153+
}
154+
sort(arr.begin(), arr.end());
155+
int n = arr.size();
156+
int ans = 0, cur = INT_MIN;
157+
for (int i = 0; i < n; ++i) {
158+
int l = arr[i].first, r = -arr[i].second;
159+
if (r <= cur) {
160+
continue;
161+
}
162+
cur = r;
163+
ans += i == n - 1 || (i < n - 1 && arr[i] != arr[i + 1]);
164+
}
165+
return ans;
166+
}
167+
};
168+
```
66169
170+
### **Go**
171+
172+
```go
173+
func visibleMountains(peaks [][]int) (ans int) {
174+
n := len(peaks)
175+
type pair struct{ l, r int }
176+
arr := make([]pair, n)
177+
for _, p := range peaks {
178+
x, y := p[0], p[1]
179+
arr = append(arr, pair{x - y, x + y})
180+
}
181+
sort.Slice(arr, func(i, j int) bool { return arr[i].l < arr[j].l || (arr[i].l == arr[j].l && arr[i].r > arr[j].r) })
182+
cur := math.MinInt32
183+
for i, e := range arr {
184+
l, r := e.l, e.r
185+
if r <= cur {
186+
continue
187+
}
188+
cur = r
189+
if !(i < n-1 && l == arr[i+1].l && r == arr[i+1].r) {
190+
ans++
191+
}
192+
}
193+
return
194+
}
67195
```
68196

69197
### **TypeScript**

‎solution/2300-2399/2345.Finding the Number of Visible Mountains/README_EN.md

+119-1
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,131 @@ Both mountains are not visible since their peaks lie within each other.
4747
### **Python3**
4848

4949
```python
50-
50+
class Solution:
51+
def visibleMountains(self, peaks: List[List[int]]) -> int:
52+
arr = [(x - y, x + y) for x, y in peaks]
53+
cnt = Counter(arr)
54+
arr.sort(key=lambda x: (x[0], -x[1]))
55+
ans, cur = 0, -inf
56+
for l, r in arr:
57+
if r <= cur:
58+
continue
59+
cur = r
60+
if cnt[(l, r)] == 1:
61+
ans += 1
62+
return ans
5163
```
5264

5365
### **Java**
5466

5567
```java
68+
class Solution {
69+
public int visibleMountains(int[][] peaks) {
70+
int n = peaks.length;
71+
int[][] arr = new int[n][2];
72+
Map<String, Integer> cnt = new HashMap<>();
73+
for (int i = 0; i < n; ++i) {
74+
int x = peaks[i][0], y = peaks[i][1];
75+
arr[i] = new int[] {x - y, x + y};
76+
cnt.merge((x - y) + "" + (x + y), 1, Integer::sum);
77+
}
78+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
79+
int ans = 0;
80+
int cur = Integer.MIN_VALUE;
81+
for (int[] e : arr) {
82+
int l = e[0], r = e[1];
83+
if (r <= cur) {
84+
continue;
85+
}
86+
cur = r;
87+
if (cnt.get(l + "" + r) == 1) {
88+
++ans;
89+
}
90+
}
91+
return ans;
92+
}
93+
}
94+
```
95+
96+
```java
97+
class Solution {
98+
public int visibleMountains(int[][] peaks) {
99+
int n = peaks.length;
100+
int[][] arr = new int[n][2];
101+
for (int i = 0; i < n; ++i) {
102+
int x = peaks[i][0], y = peaks[i][1];
103+
arr[i] = new int[] {x - y, x + y};
104+
}
105+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
106+
int ans = 0;
107+
int cur = Integer.MIN_VALUE;
108+
for (int i = 0; i < n; ++i) {
109+
int l = arr[i][0], r = arr[i][1];
110+
if (r <= cur) {
111+
continue;
112+
}
113+
cur = r;
114+
if (!(i < n - 1 && arr[i][0] == arr[i + 1][0] && arr[i][1] == arr[i + 1][1])) {
115+
++ans;
116+
}
117+
}
118+
return ans;
119+
}
120+
}
121+
```
122+
123+
### **C++**
124+
125+
```cpp
126+
class Solution {
127+
public:
128+
int visibleMountains(vector<vector<int>>& peaks) {
129+
vector<pair<int, int>> arr;
130+
for (auto& e : peaks) {
131+
int x = e[0], y = e[1];
132+
arr.emplace_back(x - y, -(x + y));
133+
}
134+
sort(arr.begin(), arr.end());
135+
int n = arr.size();
136+
int ans = 0, cur = INT_MIN;
137+
for (int i = 0; i < n; ++i) {
138+
int l = arr[i].first, r = -arr[i].second;
139+
if (r <= cur) {
140+
continue;
141+
}
142+
cur = r;
143+
ans += i == n - 1 || (i < n - 1 && arr[i] != arr[i + 1]);
144+
}
145+
return ans;
146+
}
147+
};
148+
```
56149
150+
### **Go**
151+
152+
```go
153+
func visibleMountains(peaks [][]int) (ans int) {
154+
n := len(peaks)
155+
type pair struct{ l, r int }
156+
arr := make([]pair, n)
157+
for _, p := range peaks {
158+
x, y := p[0], p[1]
159+
arr = append(arr, pair{x - y, x + y})
160+
}
161+
sort.Slice(arr, func(i, j int) bool { return arr[i].l < arr[j].l || (arr[i].l == arr[j].l && arr[i].r > arr[j].r) })
162+
cur := math.MinInt32
163+
for i, e := range arr {
164+
l, r := e.l, e.r
165+
if r <= cur {
166+
continue
167+
}
168+
cur = r
169+
if !(i < n-1 && l == arr[i+1].l && r == arr[i+1].r) {
170+
ans++
171+
}
172+
}
173+
return
174+
}
57175
```
58176

59177
### **TypeScript**

‎solution/2300-2399/2345.Finding the Number of Visible Mountains/Solution.cpp

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
int visibleMountains(vector<vector<int>>& peaks) {
4+
vector<pair<int, int>> arr;
5+
for (auto& e : peaks) {
6+
int x = e[0], y = e[1];
7+
arr.emplace_back(x - y, -(x + y));
8+
}
9+
sort(arr.begin(), arr.end());
10+
int n = arr.size();
11+
int ans = 0, cur = INT_MIN;
12+
for (int i = 0; i < n; ++i) {
13+
int l = arr[i].first, r = -arr[i].second;
14+
if (r <= cur) {
15+
continue;
16+
}
17+
cur = r;
18+
ans += i == n - 1 || (i < n - 1 && arr[i] != arr[i + 1]);
19+
}
20+
return ans;
21+
}
22+
};

‎solution/2300-2399/2345.Finding the Number of Visible Mountains/Solution.go

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
func visibleMountains(peaks [][]int) (ans int) {
2+
n := len(peaks)
3+
type pair struct{ l, r int }
4+
arr := make([]pair, n)
5+
for _, p := range peaks {
6+
x, y := p[0], p[1]
7+
arr = append(arr, pair{x - y, x + y})
8+
}
9+
sort.Slice(arr, func(i, j int) bool { return arr[i].l < arr[j].l || (arr[i].l == arr[j].l && arr[i].r > arr[j].r) })
10+
cur := math.MinInt32
11+
for i, e := range arr {
12+
l, r := e.l, e.r
13+
if r <= cur {
14+
continue
15+
}
16+
cur = r
17+
if !(i < n-1 && l == arr[i+1].l && r == arr[i+1].r) {
18+
ans++
19+
}
20+
}
21+
return
22+
}

‎solution/2300-2399/2345.Finding the Number of Visible Mountains/Solution.java

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public int visibleMountains(int[][] peaks) {
3+
int n = peaks.length;
4+
int[][] arr = new int[n][2];
5+
Map<String, Integer> cnt = new HashMap<>();
6+
for (int i = 0; i < n; ++i) {
7+
int x = peaks[i][0], y = peaks[i][1];
8+
arr[i] = new int[] {x - y, x + y};
9+
cnt.merge((x - y) + "" + (x + y), 1, Integer::sum);
10+
}
11+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
12+
int ans = 0;
13+
int cur = Integer.MIN_VALUE;
14+
for (int[] e : arr) {
15+
int l = e[0], r = e[1];
16+
if (r <= cur) {
17+
continue;
18+
}
19+
cur = r;
20+
if (cnt.get(l + "" + r) == 1) {
21+
++ans;
22+
}
23+
}
24+
return ans;
25+
}
26+
}

‎solution/2300-2399/2345.Finding the Number of Visible Mountains/Solution.py

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
class Solution:
2+
def visibleMountains(self, peaks: List[List[int]]) -> int:
3+
arr = [(x - y, x + y) for x, y in peaks]
4+
cnt = Counter(arr)
5+
arr.sort(key=lambda x: (x[0], -x[1]))
6+
ans, cur = 0, -inf
7+
for l, r in arr:
8+
if r <= cur:
9+
continue
10+
cur = r
11+
if cnt[(l, r)] == 1:
12+
ans += 1
13+
return ans

0 commit comments

Comments
 (0)