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 00ae005

Browse files
feat: add solutions to lc problem: No.2747 (#1073)
No.2747.Count Zero Request Servers
1 parent adb2162 commit 00ae005

File tree

7 files changed

+445
-6
lines changed

7 files changed

+445
-6
lines changed

‎solution/2700-2799/2747.Count Zero Request Servers/README.md‎

Lines changed: 155 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -55,34 +55,186 @@
5555

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

58+
**方法一:离线查询 + 排序 + 双指针**
59+
60+
我们可以将所有的查询按照时间从小到大排序,然后按照时间顺序依次处理每个查询。
61+
62+
对于每个查询 $q = (r, i),ドル其窗口左边界为 $l = r - x,ドル我们需要统计在窗口 $[l, r]$ 内有多少个服务器收到了请求。我们用双指针 $j$ 和 $k$ 分别维护窗口的左右边界,初始时 $j = k = 0$。每一次,如果 $k$ 指向的日志的时间小于等于 $r,ドル我们就将其加入到窗口中,然后将 $k$ 向右移动一位。如果 $j$ 指向的日志的时间小于 $l,ドル我们就将其从窗口中移除,然后将 $j$ 向右移动一位。在移动的过程中,我们需要统计窗口中有多少个不同的服务器,这可以使用哈希表来实现。移动结束后,当前时间区间中没有收到请求的服务器数目就是 $n$ 减去哈希表中不同的服务器数目。
63+
64+
时间复杂度 $O(l \times \log l + m \times \log m + n),ドル空间复杂度 $O(l + m)$。其中 $l$ 和 $n$ 分别是数组 $logs$ 的长度和服务器的数量,而 $m$ 是数组 $queries$ 的长度。
65+
5866
<!-- tabs:start -->
5967

6068
### **Python3**
6169

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

6472
```python
65-
73+
class Solution:
74+
def countServers(
75+
self, n: int, logs: List[List[int]], x: int, queries: List[int]
76+
) -> List[int]:
77+
cnt = Counter()
78+
logs.sort(key=lambda x: x[1])
79+
ans = [0] * len(queries)
80+
j = k = 0
81+
for r, i in sorted(zip(queries, count())):
82+
l = r - x
83+
while k < len(logs) and logs[k][1] <= r:
84+
cnt[logs[k][0]] += 1
85+
k += 1
86+
while j < len(logs) and logs[j][1] < l:
87+
cnt[logs[j][0]] -= 1
88+
if cnt[logs[j][0]] == 0:
89+
cnt.pop(logs[j][0])
90+
j += 1
91+
ans[i] = n - len(cnt)
92+
return ans
6693
```
6794

6895
### **Java**
6996

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

7299
```java
73-
100+
class Solution {
101+
public int[] countServers(int n, int[][] logs, int x, int[] queries) {
102+
Arrays.sort(logs, (a, b) -> a[1] - b[1]);
103+
int m = queries.length;
104+
int[][] qs = new int[m][0];
105+
for (int i = 0; i < m; ++i) {
106+
qs[i] = new int[] {queries[i], i};
107+
}
108+
Arrays.sort(qs, (a, b) -> a[0] - b[0]);
109+
Map<Integer, Integer> cnt = new HashMap<>();
110+
int[] ans = new int[m];
111+
int j = 0, k = 0;
112+
for (var q : qs) {
113+
int r = q[0], i = q[1];
114+
int l = r - x;
115+
while (k < logs.length && logs[k][1] <= r) {
116+
cnt.merge(logs[k++][0], 1, Integer::sum);
117+
}
118+
while (j < logs.length && logs[j][1] < l) {
119+
if (cnt.merge(logs[j][0], -1, Integer::sum) == 0) {
120+
cnt.remove(logs[j][0]);
121+
}
122+
j++;
123+
}
124+
ans[i] = n - cnt.size();
125+
}
126+
return ans;
127+
}
128+
}
74129
```
75130

76131
### **C++**
77132

78133
```cpp
79-
134+
class Solution {
135+
public:
136+
vector<int> countServers(int n, vector<vector<int>>& logs, int x, vector<int>& queries) {
137+
sort(logs.begin(), logs.end(), [](const auto& a, const auto& b) {
138+
return a[1] < b[1];
139+
});
140+
int m = queries.size();
141+
vector<pair<int, int>> qs(m);
142+
for (int i = 0; i < m; ++i) {
143+
qs[i] = {queries[i], i};
144+
}
145+
sort(qs.begin(), qs.end());
146+
unordered_map<int, int> cnt;
147+
vector<int> ans(m);
148+
int j = 0, k = 0;
149+
for (auto& [r, i] : qs) {
150+
int l = r - x;
151+
while (k < logs.size() && logs[k][1] <= r) {
152+
++cnt[logs[k++][0]];
153+
}
154+
while (j < logs.size() && logs[j][1] < l) {
155+
if (--cnt[logs[j][0]] == 0) {
156+
cnt.erase(logs[j][0]);
157+
}
158+
++j;
159+
}
160+
ans[i] = n - cnt.size();
161+
}
162+
return ans;
163+
}
164+
};
80165
```
81166
82167
### **Go**
83168
84169
```go
170+
func countServers(n int, logs [][]int, x int, queries []int) []int {
171+
sort.Slice(logs, func(i, j int) bool { return logs[i][1] < logs[j][1] })
172+
m := len(queries)
173+
qs := make([][2]int, m)
174+
for i, q := range queries {
175+
qs[i] = [2]int{q, i}
176+
}
177+
sort.Slice(qs, func(i, j int) bool { return qs[i][0] < qs[j][0] })
178+
cnt := map[int]int{}
179+
ans := make([]int, m)
180+
j, k := 0, 0
181+
for _, q := range qs {
182+
r, i := q[0], q[1]
183+
l := r - x
184+
for k < len(logs) && logs[k][1] <= r {
185+
cnt[logs[k][0]]++
186+
k++
187+
}
188+
for j < len(logs) && logs[j][1] < l {
189+
cnt[logs[j][0]]--
190+
if cnt[logs[j][0]] == 0 {
191+
delete(cnt, logs[j][0])
192+
}
193+
j++
194+
}
195+
ans[i] = n - len(cnt)
196+
}
197+
return ans
198+
}
199+
```
85200

201+
### **TypeScript**
202+
203+
```ts
204+
function countServers(
205+
n: number,
206+
logs: number[][],
207+
x: number,
208+
queries: number[],
209+
): number[] {
210+
logs.sort((a, b) => a[1] - b[1]);
211+
const m = queries.length;
212+
const qs: number[][] = [];
213+
for (let i = 0; i < m; ++i) {
214+
qs.push([queries[i], i]);
215+
}
216+
qs.sort((a, b) => a[0] - b[0]);
217+
const cnt: Map<number, number> = new Map();
218+
const ans: number[] = new Array(m);
219+
let j = 0;
220+
let k = 0;
221+
for (const [r, i] of qs) {
222+
const l = r - x;
223+
while (k < logs.length && logs[k][1] <= r) {
224+
cnt.set(logs[k][0], (cnt.get(logs[k][0]) || 0) + 1);
225+
++k;
226+
}
227+
while (j < logs.length && logs[j][1] < l) {
228+
cnt.set(logs[j][0], (cnt.get(logs[j][0]) || 0) - 1);
229+
if (cnt.get(logs[j][0]) === 0) {
230+
cnt.delete(logs[j][0]);
231+
}
232+
++j;
233+
}
234+
ans[i] = n - cnt.size;
235+
}
236+
return ans;
237+
}
86238
```
87239

88240
### **...**

‎solution/2700-2799/2747.Count Zero Request Servers/README_EN.md‎

Lines changed: 147 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -56,25 +56,169 @@ For queries[1]: Only server with id 3 gets no request in the duration [2,4].
5656
### **Python3**
5757

5858
```python
59-
59+
class Solution:
60+
def countServers(
61+
self, n: int, logs: List[List[int]], x: int, queries: List[int]
62+
) -> List[int]:
63+
cnt = Counter()
64+
logs.sort(key=lambda x: x[1])
65+
ans = [0] * len(queries)
66+
j = k = 0
67+
for r, i in sorted(zip(queries, count())):
68+
l = r - x
69+
while k < len(logs) and logs[k][1] <= r:
70+
cnt[logs[k][0]] += 1
71+
k += 1
72+
while j < len(logs) and logs[j][1] < l:
73+
cnt[logs[j][0]] -= 1
74+
if cnt[logs[j][0]] == 0:
75+
cnt.pop(logs[j][0])
76+
j += 1
77+
ans[i] = n - len(cnt)
78+
return ans
6079
```
6180

6281
### **Java**
6382

6483
```java
65-
84+
class Solution {
85+
public int[] countServers(int n, int[][] logs, int x, int[] queries) {
86+
Arrays.sort(logs, (a, b) -> a[1] - b[1]);
87+
int m = queries.length;
88+
int[][] qs = new int[m][0];
89+
for (int i = 0; i < m; ++i) {
90+
qs[i] = new int[] {queries[i], i};
91+
}
92+
Arrays.sort(qs, (a, b) -> a[0] - b[0]);
93+
Map<Integer, Integer> cnt = new HashMap<>();
94+
int[] ans = new int[m];
95+
int j = 0, k = 0;
96+
for (var q : qs) {
97+
int r = q[0], i = q[1];
98+
int l = r - x;
99+
while (k < logs.length && logs[k][1] <= r) {
100+
cnt.merge(logs[k++][0], 1, Integer::sum);
101+
}
102+
while (j < logs.length && logs[j][1] < l) {
103+
if (cnt.merge(logs[j][0], -1, Integer::sum) == 0) {
104+
cnt.remove(logs[j][0]);
105+
}
106+
j++;
107+
}
108+
ans[i] = n - cnt.size();
109+
}
110+
return ans;
111+
}
112+
}
66113
```
67114

68115
### **C++**
69116

70117
```cpp
71-
118+
class Solution {
119+
public:
120+
vector<int> countServers(int n, vector<vector<int>>& logs, int x, vector<int>& queries) {
121+
sort(logs.begin(), logs.end(), [](const auto& a, const auto& b) {
122+
return a[1] < b[1];
123+
});
124+
int m = queries.size();
125+
vector<pair<int, int>> qs(m);
126+
for (int i = 0; i < m; ++i) {
127+
qs[i] = {queries[i], i};
128+
}
129+
sort(qs.begin(), qs.end());
130+
unordered_map<int, int> cnt;
131+
vector<int> ans(m);
132+
int j = 0, k = 0;
133+
for (auto& [r, i] : qs) {
134+
int l = r - x;
135+
while (k < logs.size() && logs[k][1] <= r) {
136+
++cnt[logs[k++][0]];
137+
}
138+
while (j < logs.size() && logs[j][1] < l) {
139+
if (--cnt[logs[j][0]] == 0) {
140+
cnt.erase(logs[j][0]);
141+
}
142+
++j;
143+
}
144+
ans[i] = n - cnt.size();
145+
}
146+
return ans;
147+
}
148+
};
72149
```
73150
74151
### **Go**
75152
76153
```go
154+
func countServers(n int, logs [][]int, x int, queries []int) []int {
155+
sort.Slice(logs, func(i, j int) bool { return logs[i][1] < logs[j][1] })
156+
m := len(queries)
157+
qs := make([][2]int, m)
158+
for i, q := range queries {
159+
qs[i] = [2]int{q, i}
160+
}
161+
sort.Slice(qs, func(i, j int) bool { return qs[i][0] < qs[j][0] })
162+
cnt := map[int]int{}
163+
ans := make([]int, m)
164+
j, k := 0, 0
165+
for _, q := range qs {
166+
r, i := q[0], q[1]
167+
l := r - x
168+
for k < len(logs) && logs[k][1] <= r {
169+
cnt[logs[k][0]]++
170+
k++
171+
}
172+
for j < len(logs) && logs[j][1] < l {
173+
cnt[logs[j][0]]--
174+
if cnt[logs[j][0]] == 0 {
175+
delete(cnt, logs[j][0])
176+
}
177+
j++
178+
}
179+
ans[i] = n - len(cnt)
180+
}
181+
return ans
182+
}
183+
```
77184

185+
### **TypeScript**
186+
187+
```ts
188+
function countServers(
189+
n: number,
190+
logs: number[][],
191+
x: number,
192+
queries: number[],
193+
): number[] {
194+
logs.sort((a, b) => a[1] - b[1]);
195+
const m = queries.length;
196+
const qs: number[][] = [];
197+
for (let i = 0; i < m; ++i) {
198+
qs.push([queries[i], i]);
199+
}
200+
qs.sort((a, b) => a[0] - b[0]);
201+
const cnt: Map<number, number> = new Map();
202+
const ans: number[] = new Array(m);
203+
let j = 0;
204+
let k = 0;
205+
for (const [r, i] of qs) {
206+
const l = r - x;
207+
while (k < logs.length && logs[k][1] <= r) {
208+
cnt.set(logs[k][0], (cnt.get(logs[k][0]) || 0) + 1);
209+
++k;
210+
}
211+
while (j < logs.length && logs[j][1] < l) {
212+
cnt.set(logs[j][0], (cnt.get(logs[j][0]) || 0) - 1);
213+
if (cnt.get(logs[j][0]) === 0) {
214+
cnt.delete(logs[j][0]);
215+
}
216+
++j;
217+
}
218+
ans[i] = n - cnt.size;
219+
}
220+
return ans;
221+
}
78222
```
79223

80224
### **...**
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
class Solution {
2+
public:
3+
vector<int> countServers(int n, vector<vector<int>>& logs, int x, vector<int>& queries) {
4+
sort(logs.begin(), logs.end(), [](const auto& a, const auto& b) {
5+
return a[1] < b[1];
6+
});
7+
int m = queries.size();
8+
vector<pair<int, int>> qs(m);
9+
for (int i = 0; i < m; ++i) {
10+
qs[i] = {queries[i], i};
11+
}
12+
sort(qs.begin(), qs.end());
13+
unordered_map<int, int> cnt;
14+
vector<int> ans(m);
15+
int j = 0, k = 0;
16+
for (auto& [r, i] : qs) {
17+
int l = r - x;
18+
while (k < logs.size() && logs[k][1] <= r) {
19+
++cnt[logs[k++][0]];
20+
}
21+
while (j < logs.size() && logs[j][1] < l) {
22+
if (--cnt[logs[j][0]] == 0) {
23+
cnt.erase(logs[j][0]);
24+
}
25+
++j;
26+
}
27+
ans[i] = n - cnt.size();
28+
}
29+
return ans;
30+
}
31+
};

0 commit comments

Comments
(0)

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