Skip to content

Commit b0e7b54

Browse files
Srihari2222Srihari2222
authored
Sri Hari: Batch-5/Neetcode-ALL/Added-articles (#3841)
* Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles * Batch-5/Neetcode-ALL/Added-articles
1 parent 803157a commit b0e7b54

File tree

52 files changed

+27731
-0
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

52 files changed

+27731
-0
lines changed

Diff for: ‎articles/all-possible-full-binary-trees.md

+693
Large diffs are not rendered by default.

Diff for: ‎articles/binary-search-tree-iterator.md

+699
Large diffs are not rendered by default.

Diff for: ‎articles/concatenated-words.md

+587
Large diffs are not rendered by default.

Diff for: ‎articles/count-all-valid-pickup-and-delivery-options.md

+668
Large diffs are not rendered by default.

Diff for: ‎articles/data-stream-as-disjoint-intervals.md

+450
Large diffs are not rendered by default.

Diff for: ‎articles/design-browser-history.md

+640
Large diffs are not rendered by default.

Diff for: ‎articles/detonate-the-maximum-bombs.md

+522
Large diffs are not rendered by default.

Diff for: ‎articles/distribute-coins-in-binary-tree.md

+723
Large diffs are not rendered by default.

Diff for: ‎articles/eliminate-maximum-number-of-monsters.md

+298
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,298 @@
1+
## 1. Sorting
2+
3+
::tabs-start
4+
5+
```python
6+
class Solution:
7+
def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
8+
minReach = [math.ceil(d / s) for d, s in zip(dist, speed)]
9+
minReach.sort()
10+
11+
res = 0
12+
for minute in range(len(minReach)):
13+
if minute >= minReach[minute]:
14+
return res
15+
res += 1
16+
17+
return res
18+
```
19+
20+
```java
21+
public class Solution {
22+
public int eliminateMaximum(int[] dist, int[] speed) {
23+
int n = dist.length;
24+
int[] minReach = new int[n];
25+
26+
for (int i = 0; i < n; i++) {
27+
minReach[i] = (int) Math.ceil((double) dist[i] / speed[i]);
28+
}
29+
30+
Arrays.sort(minReach);
31+
32+
int res = 0;
33+
for (int minute = 0; minute < n; minute++) {
34+
if (minute >= minReach[minute]) {
35+
return res;
36+
}
37+
res++;
38+
}
39+
40+
return res;
41+
}
42+
}
43+
```
44+
45+
```cpp
46+
class Solution {
47+
public:
48+
int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
49+
int n = dist.size();
50+
vector<int> minReach(n);
51+
52+
for (int i = 0; i < n; i++) {
53+
minReach[i] = ceil((double)dist[i] / speed[i]);
54+
}
55+
56+
sort(minReach.begin(), minReach.end());
57+
58+
int res = 0;
59+
for (int minute = 0; minute < n; minute++) {
60+
if (minute >= minReach[minute]) {
61+
return res;
62+
}
63+
res++;
64+
}
65+
66+
return res;
67+
}
68+
};
69+
```
70+
71+
```javascript
72+
class Solution {
73+
/**
74+
* @param {number[]} dist
75+
* @param {number[]} speed
76+
* @return {number}
77+
*/
78+
eliminateMaximum(dist, speed) {
79+
let n = dist.length;
80+
let minReach = new Array(n);
81+
82+
for (let i = 0; i < n; i++) {
83+
minReach[i] = Math.ceil(dist[i] / speed[i]);
84+
}
85+
86+
minReach.sort((a, b) => a - b);
87+
88+
let res = 0;
89+
for (let minute = 0; minute < n; minute++) {
90+
if (minute >= minReach[minute]) {
91+
return res;
92+
}
93+
res++;
94+
}
95+
96+
return res;
97+
}
98+
}
99+
```
100+
101+
::tabs-end
102+
103+
### Time & Space Complexity
104+
105+
* Time complexity: $O(n \log n)$
106+
* Space complexity: $O(n)$
107+
108+
---
109+
110+
## 2. Sorting (Overwrting Input Array)
111+
112+
::tabs-start
113+
114+
```python
115+
class Solution:
116+
def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
117+
for i in range(len(dist)):
118+
dist[i] = math.ceil(dist[i] / speed[i])
119+
120+
dist.sort()
121+
for minute in range(len(dist)):
122+
if minute >= dist[minute]:
123+
return minute
124+
125+
return len(dist)
126+
```
127+
128+
```java
129+
public class Solution {
130+
public int eliminateMaximum(int[] dist, int[] speed) {
131+
int n = dist.length;
132+
for (int i = 0; i < n; i++) {
133+
dist[i] = (int) Math.ceil((double) dist[i] / speed[i]);
134+
}
135+
136+
Arrays.sort(dist);
137+
for (int minute = 0; minute < n; minute++) {
138+
if (minute >= dist[minute]) {
139+
return minute;
140+
}
141+
}
142+
143+
return n;
144+
}
145+
}
146+
```
147+
148+
```cpp
149+
class Solution {
150+
public:
151+
int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
152+
int n = dist.size();
153+
for (int i = 0; i < n; i++) {
154+
dist[i] = ceil((double)dist[i] / speed[i]);
155+
}
156+
157+
sort(dist.begin(), dist.end());
158+
for (int minute = 0; minute < n; minute++) {
159+
if (minute >= dist[minute]) {
160+
return minute;
161+
}
162+
}
163+
164+
return n;
165+
}
166+
};
167+
```
168+
169+
```javascript
170+
class Solution {
171+
/**
172+
* @param {number[]} dist
173+
* @param {number[]} speed
174+
* @return {number}
175+
*/
176+
eliminateMaximum(dist, speed) {
177+
let n = dist.length;
178+
for (let i = 0; i < n; i++) {
179+
dist[i] = Math.ceil(dist[i] / speed[i]);
180+
}
181+
182+
dist.sort((a, b) => a - b);
183+
for (let minute = 0; minute < n; minute++) {
184+
if (minute >= dist[minute]) {
185+
return minute;
186+
}
187+
}
188+
189+
return n;
190+
}
191+
}
192+
```
193+
194+
::tabs-end
195+
196+
### Time & Space Complexity
197+
198+
* Time complexity: $O(n \log n)$
199+
* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
200+
201+
---
202+
203+
## 3. Min-Heap
204+
205+
::tabs-start
206+
207+
```python
208+
class Solution:
209+
def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
210+
minHeap = []
211+
for i in range(len(dist)):
212+
heapq.heappush(minHeap, dist[i] / speed[i])
213+
214+
res = 0
215+
while minHeap:
216+
if res >= heapq.heappop(minHeap):
217+
return res
218+
res += 1
219+
220+
return res
221+
```
222+
223+
```java
224+
public class Solution {
225+
public int eliminateMaximum(int[] dist, int[] speed) {
226+
PriorityQueue<Double> minHeap = new PriorityQueue<>();
227+
for (int i = 0; i < dist.length; i++) {
228+
minHeap.add((double) dist[i] / speed[i]);
229+
}
230+
231+
int res = 0;
232+
while (!minHeap.isEmpty()) {
233+
if (res >= minHeap.poll()) {
234+
return res;
235+
}
236+
res++;
237+
}
238+
239+
return res;
240+
}
241+
}
242+
```
243+
244+
```cpp
245+
class Solution {
246+
public:
247+
int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
248+
priority_queue<double, vector<double>, greater<double>> minHeap;
249+
for (int i = 0; i < dist.size(); i++) {
250+
minHeap.push((double)dist[i] / speed[i]);
251+
}
252+
253+
int res = 0;
254+
while (!minHeap.empty()) {
255+
if (res >= minHeap.top()) {
256+
return res;
257+
}
258+
minHeap.pop();
259+
res++;
260+
}
261+
262+
return res;
263+
}
264+
};
265+
```
266+
267+
```javascript
268+
class Solution {
269+
/**
270+
* @param {number[]} dist
271+
* @param {number[]} speed
272+
* @return {number}
273+
*/
274+
eliminateMaximum(dist, speed) {
275+
const minHeap = new MinPriorityQueue();
276+
for (let i = 0; i < dist.length; i++) {
277+
minHeap.enqueue(dist[i] / speed[i]);
278+
}
279+
280+
let res = 0;
281+
while (!minHeap.isEmpty()) {
282+
if (res >= minHeap.dequeue().element) {
283+
return res;
284+
}
285+
res++;
286+
}
287+
288+
return res;
289+
}
290+
}
291+
```
292+
293+
::tabs-end
294+
295+
### Time & Space Complexity
296+
297+
* Time complexity: $O(n \log n)$
298+
* Space complexity: $O(n)$

0 commit comments

Comments
 (0)