Skip to content

Commit b82c716

Browse files
yanglbmeyanglbme
committedFeb 25, 2023
feat: add solutions to lc problem: No.2021
No.2021.Brightest Position on Street
1 parent 12cc7d1 commit b82c716

File tree

7 files changed

+219
-116
lines changed

7 files changed

+219
-116
lines changed
 

‎solution/2000-2099/2021.Brightest Position on Street/README.md

+80-40
Original file line numberDiff line numberDiff line change
@@ -54,9 +54,15 @@
5454

5555
<!-- 这里可写通用的实现逻辑 -->
5656

57-
差分数组 + 排序。
57+
**方法一：差分数组 + 哈希表 + 排序**
5858

59-
如果用数组实现，空间分配过大。因此可以使用哈希表 + 排序，或者直接使用 TreeMap。
59+
我们可以将每个路灯照亮的范围看作是一个区间，区间左端点 $l = position_i - range_i$，区间右端点 $r = position_i + range_i$。我们可以利用差分数组的思想，对于每个区间 $[l, r]$，将位置 $l$ 的值加 $1$，将位置 $r + 1$ 的值减 $1$，用哈希表维护每个位置的变化值。
60+
61+
然后从小到大遍历每个位置，计算当前位置的亮度 $s$，如果此前的最大亮度 $mx \lt s$，则更新最大亮度 $mx = s$，并记录当前位置 $ans = i$。
62+
63+
最后返回 $ans$ 即可。
64+
65+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为 $lights$ 的长度。
6066

6167
<!-- tabs:start -->
6268

@@ -68,13 +74,14 @@
6874
class Solution:
6975
def brightestPosition(self, lights: List[List[int]]) -> int:
7076
d = defaultdict(int)
71-
for p, r in lights:
72-
d[p - r] += 1
73-
d[p + r + 1] -= 1
74-
s = mx = ans = 0
77+
for i, j in lights:
78+
l, r = i - j, i + j
79+
d[l] += 1
80+
d[r + 1] -= 1
81+
ans = s = mx = 0
7582
for k in sorted(d):
7683
s += d[k]
77-
if s > mx:
84+
if mx < s:
7885
mx = s
7986
ans = k
8087
return ans
@@ -88,17 +95,18 @@ class Solution:
8895
class Solution {
8996
public int brightestPosition(int[][] lights) {
9097
TreeMap<Integer, Integer> d = new TreeMap<>();
91-
for (int[] e : lights) {
92-
int l = e[0] - e[1], r = e[0] + e[1];
93-
d.put(l, d.getOrDefault(l, 0) + 1);
94-
d.put(r + 1, d.getOrDefault(r + 1, 0) - 1);
98+
for (var x : lights) {
99+
int l = x[0] - x[1], r = x[0] + x[1];
100+
d.merge(l, 1, Integer::sum);
101+
d.merge(r + 1, -1, Integer::sum);
95102
}
96-
int s = 0, mx = 0, ans = 0;
97-
for (Map.Entry<Integer, Integer> e : d.entrySet()) {
98-
s += e.getValue();
99-
if (s > mx) {
103+
int ans = 0, s = 0, mx = 0;
104+
for (var x : d.entrySet()) {
105+
int v = x.getValue();
106+
s += v;
107+
if (mx < s) {
100108
mx = s;
101-
ans = e.getKey();
109+
ans = x.getKey();
102110
}
103111
}
104112
return ans;
@@ -113,17 +121,17 @@ class Solution {
113121
public:
114122
int brightestPosition(vector<vector<int>>& lights) {
115123
map<int, int> d;
116-
for (auto& e : lights) {
117-
int l = e[0] - e[1], r = e[0] + e[1];
124+
for (auto& x : lights) {
125+
int l = x[0] - x[1], r = x[0] + x[1];
118126
++d[l];
119127
--d[r + 1];
120128
}
121-
int s = 0, mx = 0, ans = 0;
122-
for (auto& e : d) {
123-
s += e.second;
124-
if (s > mx) {
129+
int ans = 0, s = 0, mx = 0;
130+
for (auto& [i, v] : d) {
131+
s += v;
132+
if (mx < s) {
125133
mx = s;
126-
ans = e.first;
134+
ans = i;
127135
}
128136
}
129137
return ans;
@@ -134,32 +142,64 @@ public:
134142
### **Go**
135143
136144
```go
137-
func brightestPosition(lights [][]int) int {
138-
d := make(map[int]int)
139-
for _, e := range lights {
140-
l, r := e[0]-e[1], e[0]+e[1]
141-
d[l] += 1
142-
d[r+1] -= 1
145+
func brightestPosition(lights [][]int) (ans int) {
146+
d := map[int]int{}
147+
for _, x := range lights {
148+
l, r := x[0]-x[1], x[0]+x[1]
149+
d[l]++
150+
d[r+1]--
143151
}
144-
145-
var keys []int
146-
for k := range d {
147-
keys = append(keys, k)
152+
keys := make([]int, 0, len(d))
153+
for i := range d {
154+
keys = append(keys, i)
148155
}
149156
sort.Ints(keys)
150-
151-
s, mx, ans := 0, 0, 0
152-
for _, k := range keys {
153-
s += d[k]
154-
if s > mx {
157+
mx, s := 0, 0
158+
for _, i := range keys {
159+
s += d[i]
160+
if mx < s {
155161
mx = s
156-
ans = k
162+
ans = i
157163
}
158164
}
159-
return ans
165+
return
160166
}
161167
```
162168

169+
### **JavaScript**
170+
171+
```js
172+
/**
173+
* @param {number[][]} lights
174+
* @return {number}
175+
*/
176+
var brightestPosition = function (lights) {
177+
const d = new Map();
178+
for (const [i, j] of lights) {
179+
const l = i - j;
180+
const r = i + j;
181+
d.set(l, (d.get(l) ?? 0) + 1);
182+
d.set(r + 1, (d.get(r + 1) ?? 0) - 1);
183+
}
184+
const keys = [];
185+
for (const k of d.keys()) {
186+
keys.push(k);
187+
}
188+
keys.sort((a, b) => a - b);
189+
let ans = 0;
190+
let s = 0;
191+
let mx = 0;
192+
for (const i of keys) {
193+
s += d.get(i);
194+
if (mx < s) {
195+
mx = s;
196+
ans = i;
197+
}
198+
}
199+
return ans;
200+
};
201+
```
202+
163203
### **...**
164204
165205
```

‎solution/2000-2099/2021.Brightest Position on Street/README_EN.md

+72-38
Original file line numberDiff line numberDiff line change
@@ -72,13 +72,14 @@ Out of all these positions, -1 is the smallest, so return it.
7272
class Solution:
7373
def brightestPosition(self, lights: List[List[int]]) -> int:
7474
d = defaultdict(int)
75-
for p, r in lights:
76-
d[p - r] += 1
77-
d[p + r + 1] -= 1
78-
s = mx = ans = 0
75+
for i, j in lights:
76+
l, r = i - j, i + j
77+
d[l] += 1
78+
d[r + 1] -= 1
79+
ans = s = mx = 0
7980
for k in sorted(d):
8081
s += d[k]
81-
if s > mx:
82+
if mx < s:
8283
mx = s
8384
ans = k
8485
return ans
@@ -90,17 +91,18 @@ class Solution:
9091
class Solution {
9192
public int brightestPosition(int[][] lights) {
9293
TreeMap<Integer, Integer> d = new TreeMap<>();
93-
for (int[] e : lights) {
94-
int l = e[0] - e[1], r = e[0] + e[1];
95-
d.put(l, d.getOrDefault(l, 0) + 1);
96-
d.put(r + 1, d.getOrDefault(r + 1, 0) - 1);
94+
for (var x : lights) {
95+
int l = x[0] - x[1], r = x[0] + x[1];
96+
d.merge(l, 1, Integer::sum);
97+
d.merge(r + 1, -1, Integer::sum);
9798
}
98-
int s = 0, mx = 0, ans = 0;
99-
for (Map.Entry<Integer, Integer> e : d.entrySet()) {
100-
s += e.getValue();
101-
if (s > mx) {
99+
int ans = 0, s = 0, mx = 0;
100+
for (var x : d.entrySet()) {
101+
int v = x.getValue();
102+
s += v;
103+
if (mx < s) {
102104
mx = s;
103-
ans = e.getKey();
105+
ans = x.getKey();
104106
}
105107
}
106108
return ans;
@@ -115,17 +117,17 @@ class Solution {
115117
public:
116118
int brightestPosition(vector<vector<int>>& lights) {
117119
map<int, int> d;
118-
for (auto& e : lights) {
119-
int l = e[0] - e[1], r = e[0] + e[1];
120+
for (auto& x : lights) {
121+
int l = x[0] - x[1], r = x[0] + x[1];
120122
++d[l];
121123
--d[r + 1];
122124
}
123-
int s = 0, mx = 0, ans = 0;
124-
for (auto& e : d) {
125-
s += e.second;
126-
if (s > mx) {
125+
int ans = 0, s = 0, mx = 0;
126+
for (auto& [i, v] : d) {
127+
s += v;
128+
if (mx < s) {
127129
mx = s;
128-
ans = e.first;
130+
ans = i;
129131
}
130132
}
131133
return ans;
@@ -136,32 +138,64 @@ public:
136138
### **Go**
137139
138140
```go
139-
func brightestPosition(lights [][]int) int {
140-
d := make(map[int]int)
141-
for _, e := range lights {
142-
l, r := e[0]-e[1], e[0]+e[1]
143-
d[l] += 1
144-
d[r+1] -= 1
141+
func brightestPosition(lights [][]int) (ans int) {
142+
d := map[int]int{}
143+
for _, x := range lights {
144+
l, r := x[0]-x[1], x[0]+x[1]
145+
d[l]++
146+
d[r+1]--
145147
}
146-
147-
var keys []int
148-
for k := range d {
149-
keys = append(keys, k)
148+
keys := make([]int, 0, len(d))
149+
for i := range d {
150+
keys = append(keys, i)
150151
}
151152
sort.Ints(keys)
152-
153-
s, mx, ans := 0, 0, 0
154-
for _, k := range keys {
155-
s += d[k]
156-
if s > mx {
153+
mx, s := 0, 0
154+
for _, i := range keys {
155+
s += d[i]
156+
if mx < s {
157157
mx = s
158-
ans = k
158+
ans = i
159159
}
160160
}
161-
return ans
161+
return
162162
}
163163
```
164164

165+
### **JavaScript**
166+
167+
```js
168+
/**
169+
* @param {number[][]} lights
170+
* @return {number}
171+
*/
172+
var brightestPosition = function (lights) {
173+
const d = new Map();
174+
for (const [i, j] of lights) {
175+
const l = i - j;
176+
const r = i + j;
177+
d.set(l, (d.get(l) ?? 0) + 1);
178+
d.set(r + 1, (d.get(r + 1) ?? 0) - 1);
179+
}
180+
const keys = [];
181+
for (const k of d.keys()) {
182+
keys.push(k);
183+
}
184+
keys.sort((a, b) => a - b);
185+
let ans = 0;
186+
let s = 0;
187+
let mx = 0;
188+
for (const i of keys) {
189+
s += d.get(i);
190+
if (mx < s) {
191+
mx = s;
192+
ans = i;
193+
}
194+
}
195+
return ans;
196+
};
197+
```
198+
165199
### **...**
166200
167201
```

‎solution/2000-2099/2021.Brightest Position on Street/Solution.cpp

+7-7
Original file line numberDiff line numberDiff line change
@@ -2,17 +2,17 @@ class Solution {
22
public:
33
int brightestPosition(vector<vector<int>>& lights) {
44
map<int, int> d;
5-
for (auto& e : lights) {
6-
int l = e[0] - e[1], r = e[0] + e[1];
5+
for (auto& x : lights) {
6+
int l = x[0] - x[1], r = x[0] + x[1];
77
++d[l];
88
--d[r + 1];
99
}
10-
int s = 0, mx = 0, ans = 0;
11-
for (auto& e : d) {
12-
s += e.second;
13-
if (s > mx) {
10+
int ans = 0, s = 0, mx = 0;
11+
for (auto& [i, v] : d) {
12+
s += v;
13+
if (mx < s) {
1414
mx = s;
15-
ans = e.first;
15+
ans = i;
1616
}
1717
}
1818
return ans;

‎solution/2000-2099/2021.Brightest Position on Street/Solution.go

+15-17
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,22 @@
1-
func brightestPosition(lights [][]int) int {
2-
d := make(map[int]int)
3-
for _, e := range lights {
4-
l, r := e[0]-e[1], e[0]+e[1]
5-
d[l] += 1
6-
d[r+1] -= 1
1+
func brightestPosition(lights [][]int) (ans int) {
2+
d := map[int]int{}
3+
for _, x := range lights {
4+
l, r := x[0]-x[1], x[0]+x[1]
5+
d[l]++
6+
d[r+1]--
77
}
8-
9-
var keys []int
10-
for k := range d {
11-
keys = append(keys, k)
8+
keys := make([]int, 0, len(d))
9+
for i := range d {
10+
keys = append(keys, i)
1211
}
1312
sort.Ints(keys)
14-
15-
s, mx, ans := 0, 0, 0
16-
for _, k := range keys {
17-
s += d[k]
18-
if s > mx {
13+
mx, s := 0, 0
14+
for _, i := range keys {
15+
s += d[i]
16+
if mx < s {
1917
mx = s
20-
ans = k
18+
ans = i
2119
}
2220
}
23-
return ans
21+
return
2422
}

0 commit comments

Comments
 (0)