Skip to content

Commit eb6d08f

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3679 (#4725)
1 parent d7374bc commit eb6d08f

File tree

7 files changed

+322
-8
lines changed

7 files changed

+322
-8
lines changed

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/README.md

Lines changed: 113 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -91,32 +91,141 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3679.Mi
9191

9292
<!-- solution:start -->
9393

94-
### 方法一
94+
### 方法一：模拟 + 滑动窗口
95+
96+
我们用一个哈希表 $\textit{cnt}$ 来记录当前窗口中每种物品的数量，用一个数组 $\textit{marked}$ 来记录每个物品是否被保留。
97+
98+
我们从左到右遍历数组，对于每个物品 $x$：
99+
100+
1. 如果当前天数 $i$ 大于等于窗口大小 $w$，则需要将窗口最左侧的物品数量减去 $\textit{marked}[i - w]$（如果该物品被保留的话）。
101+
2. 如果当前物品在窗口中的数量超过了 $m$，则需要丢弃该物品。
102+
3. 否则，保留该物品，并将其数量加一。
103+
104+
最终，答案即为被丢弃的物品数量。
105+
106+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
95107

96108
<!-- tabs:start -->
97109

98110
#### Python3
99111

100112
```python
101-
113+
class Solution:
114+
def minArrivalsToDiscard(self, arrivals: List[int], w: int, m: int) -> int:
115+
cnt = Counter()
116+
n = len(arrivals)
117+
marked = [0] * n
118+
ans = 0
119+
for i, x in enumerate(arrivals):
120+
if i >= w:
121+
cnt[arrivals[i - w]] -= marked[i - w]
122+
if cnt[x] >= m:
123+
ans += 1
124+
else:
125+
marked[i] = 1
126+
cnt[x] += 1
127+
return ans
102128
```
103129

104130
#### Java
105131

106132
```java
107-
133+
class Solution {
134+
public int minArrivalsToDiscard(int[] arrivals, int w, int m) {
135+
Map<Integer, Integer> cnt = new HashMap<>();
136+
int n = arrivals.length;
137+
int[] marked = new int[n];
138+
int ans = 0;
139+
for (int i = 0; i < n; i++) {
140+
int x = arrivals[i];
141+
if (i >= w) {
142+
int prev = arrivals[i - w];
143+
cnt.merge(prev, -marked[i - w], Integer::sum);
144+
}
145+
if (cnt.getOrDefault(x, 0) >= m) {
146+
ans++;
147+
} else {
148+
marked[i] = 1;
149+
cnt.merge(x, 1, Integer::sum);
150+
}
151+
}
152+
return ans;
153+
}
154+
}
108155
```
109156

110157
#### C++
111158

112159
```cpp
113-
160+
class Solution {
161+
public:
162+
int minArrivalsToDiscard(vector<int>& arrivals, int w, int m) {
163+
unordered_map<int, int> cnt;
164+
int n = arrivals.size();
165+
vector<int> marked(n, 0);
166+
int ans = 0;
167+
for (int i = 0; i < n; i++) {
168+
int x = arrivals[i];
169+
if (i >= w) {
170+
cnt[arrivals[i - w]] -= marked[i - w];
171+
}
172+
if (cnt[x] >= m) {
173+
ans++;
174+
} else {
175+
marked[i] = 1;
176+
cnt[x] += 1;
177+
}
178+
}
179+
return ans;
180+
}
181+
};
114182
```
115183
116184
#### Go
117185
118186
```go
187+
func minArrivalsToDiscard(arrivals []int, w int, m int) (ans int) {
188+
cnt := make(map[int]int)
189+
n := len(arrivals)
190+
marked := make([]int, n)
191+
for i, x := range arrivals {
192+
if i >= w {
193+
cnt[arrivals[i-w]] -= marked[i-w]
194+
}
195+
if cnt[x] >= m {
196+
ans++
197+
} else {
198+
marked[i] = 1
199+
cnt[x]++
200+
}
201+
}
202+
return
203+
}
204+
```
119205

206+
#### TypeScript
207+
208+
```ts
209+
function minArrivalsToDiscard(arrivals: number[], w: number, m: number): number {
210+
const cnt = new Map<number, number>();
211+
const n = arrivals.length;
212+
const marked = Array<number>(n).fill(0);
213+
let ans = 0;
214+
215+
for (let i = 0; i < n; i++) {
216+
const x = arrivals[i];
217+
if (i >= w) {
218+
cnt.set(arrivals[i - w], (cnt.get(arrivals[i - w]) || 0) - marked[i - w]);
219+
}
220+
if ((cnt.get(x) || 0) >= m) {
221+
ans++;
222+
} else {
223+
marked[i] = 1;
224+
cnt.set(x, (cnt.get(x) || 0) + 1);
225+
}
226+
}
227+
return ans;
228+
}
120229
```
121230

122231
<!-- tabs:end -->

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/README_EN.md

Lines changed: 113 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -89,32 +89,141 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3679.Mi
8989

9090
<!-- solution:start -->
9191

92-
### Solution 1
92+
### Solution 1: Simulation + Sliding Window
93+
94+
We use a hash map $\textit{cnt}$ to record the quantity of each item type in the current window, and an array $\textit{marked}$ to record whether each item is kept.
95+
96+
We iterate through the array from left to right. For each item $x$:
97+
98+
1. If the current day $i$ is greater than or equal to the window size $w$, we subtract $\textit{marked}[i - w]$ from the count of the leftmost item in the window (if that item was kept).
99+
2. If the quantity of the current item in the window exceeds $m$, we discard the item.
100+
3. Otherwise, we keep the item and increment its count.
101+
102+
Finally, the answer is the number of items discarded.
103+
104+
The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array.
93105

94106
<!-- tabs:start -->
95107

96108
#### Python3
97109

98110
```python
99-
111+
class Solution:
112+
def minArrivalsToDiscard(self, arrivals: List[int], w: int, m: int) -> int:
113+
cnt = Counter()
114+
n = len(arrivals)
115+
marked = [0] * n
116+
ans = 0
117+
for i, x in enumerate(arrivals):
118+
if i >= w:
119+
cnt[arrivals[i - w]] -= marked[i - w]
120+
if cnt[x] >= m:
121+
ans += 1
122+
else:
123+
marked[i] = 1
124+
cnt[x] += 1
125+
return ans
100126
```
101127

102128
#### Java
103129

104130
```java
105-
131+
class Solution {
132+
public int minArrivalsToDiscard(int[] arrivals, int w, int m) {
133+
Map<Integer, Integer> cnt = new HashMap<>();
134+
int n = arrivals.length;
135+
int[] marked = new int[n];
136+
int ans = 0;
137+
for (int i = 0; i < n; i++) {
138+
int x = arrivals[i];
139+
if (i >= w) {
140+
int prev = arrivals[i - w];
141+
cnt.merge(prev, -marked[i - w], Integer::sum);
142+
}
143+
if (cnt.getOrDefault(x, 0) >= m) {
144+
ans++;
145+
} else {
146+
marked[i] = 1;
147+
cnt.merge(x, 1, Integer::sum);
148+
}
149+
}
150+
return ans;
151+
}
152+
}
106153
```
107154

108155
#### C++
109156

110157
```cpp
111-
158+
class Solution {
159+
public:
160+
int minArrivalsToDiscard(vector<int>& arrivals, int w, int m) {
161+
unordered_map<int, int> cnt;
162+
int n = arrivals.size();
163+
vector<int> marked(n, 0);
164+
int ans = 0;
165+
for (int i = 0; i < n; i++) {
166+
int x = arrivals[i];
167+
if (i >= w) {
168+
cnt[arrivals[i - w]] -= marked[i - w];
169+
}
170+
if (cnt[x] >= m) {
171+
ans++;
172+
} else {
173+
marked[i] = 1;
174+
cnt[x] += 1;
175+
}
176+
}
177+
return ans;
178+
}
179+
};
112180
```
113181
114182
#### Go
115183
116184
```go
185+
func minArrivalsToDiscard(arrivals []int, w int, m int) (ans int) {
186+
cnt := make(map[int]int)
187+
n := len(arrivals)
188+
marked := make([]int, n)
189+
for i, x := range arrivals {
190+
if i >= w {
191+
cnt[arrivals[i-w]] -= marked[i-w]
192+
}
193+
if cnt[x] >= m {
194+
ans++
195+
} else {
196+
marked[i] = 1
197+
cnt[x]++
198+
}
199+
}
200+
return
201+
}
202+
```
117203

204+
#### TypeScript
205+
206+
```ts
207+
function minArrivalsToDiscard(arrivals: number[], w: number, m: number): number {
208+
const cnt = new Map<number, number>();
209+
const n = arrivals.length;
210+
const marked = Array<number>(n).fill(0);
211+
let ans = 0;
212+
213+
for (let i = 0; i < n; i++) {
214+
const x = arrivals[i];
215+
if (i >= w) {
216+
cnt.set(arrivals[i - w], (cnt.get(arrivals[i - w]) || 0) - marked[i - w]);
217+
}
218+
if ((cnt.get(x) || 0) >= m) {
219+
ans++;
220+
} else {
221+
marked[i] = 1;
222+
cnt.set(x, (cnt.get(x) || 0) + 1);
223+
}
224+
}
225+
return ans;
226+
}
118227
```
119228

120229
<!-- tabs:end -->

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/Solution.cpp

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
int minArrivalsToDiscard(vector<int>& arrivals, int w, int m) {
4+
unordered_map<int, int> cnt;
5+
int n = arrivals.size();
6+
vector<int> marked(n, 0);
7+
int ans = 0;
8+
for (int i = 0; i < n; i++) {
9+
int x = arrivals[i];
10+
if (i >= w) {
11+
cnt[arrivals[i - w]] -= marked[i - w];
12+
}
13+
if (cnt[x] >= m) {
14+
ans++;
15+
} else {
16+
marked[i] = 1;
17+
cnt[x] += 1;
18+
}
19+
}
20+
return ans;
21+
}
22+
};

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/Solution.go

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
func minArrivalsToDiscard(arrivals []int, w int, m int) (ans int) {
2+
cnt := make(map[int]int)
3+
n := len(arrivals)
4+
marked := make([]int, n)
5+
for i, x := range arrivals {
6+
if i >= w {
7+
cnt[arrivals[i-w]] -= marked[i-w]
8+
}
9+
if cnt[x] >= m {
10+
ans++
11+
} else {
12+
marked[i] = 1
13+
cnt[x]++
14+
}
15+
}
16+
return
17+
}

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/Solution.java

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public int minArrivalsToDiscard(int[] arrivals, int w, int m) {
3+
Map<Integer, Integer> cnt = new HashMap<>();
4+
int n = arrivals.length;
5+
int[] marked = new int[n];
6+
int ans = 0;
7+
for (int i = 0; i < n; i++) {
8+
int x = arrivals[i];
9+
if (i >= w) {
10+
int prev = arrivals[i - w];
11+
cnt.merge(prev, -marked[i - w], Integer::sum);
12+
}
13+
if (cnt.getOrDefault(x, 0) >= m) {
14+
ans++;
15+
} else {
16+
marked[i] = 1;
17+
cnt.merge(x, 1, Integer::sum);
18+
}
19+
}
20+
return ans;
21+
}
22+
}

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/Solution.py

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution:
2+
def minArrivalsToDiscard(self, arrivals: List[int], w: int, m: int) -> int:
3+
cnt = Counter()
4+
n = len(arrivals)
5+
marked = [0] * n
6+
ans = 0
7+
for i, x in enumerate(arrivals):
8+
if i >= w:
9+
cnt[arrivals[i - w]] -= marked[i - w]
10+
if cnt[x] >= m:
11+
ans += 1
12+
else:
13+
marked[i] = 1
14+
cnt[x] += 1
15+
return ans

‎solution/3600-3699/3679.Minimum Discards to Balance Inventory/Solution.ts

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
function minArrivalsToDiscard(arrivals: number[], w: number, m: number): number {
2+
const cnt = new Map<number, number>();
3+
const n = arrivals.length;
4+
const marked = Array<number>(n).fill(0);
5+
let ans = 0;
6+
7+
for (let i = 0; i < n; i++) {
8+
const x = arrivals[i];
9+
if (i >= w) {
10+
cnt.set(arrivals[i - w], (cnt.get(arrivals[i - w]) || 0) - marked[i - w]);
11+
}
12+
if ((cnt.get(x) || 0) >= m) {
13+
ans++;
14+
} else {
15+
marked[i] = 1;
16+
cnt.set(x, (cnt.get(x) || 0) + 1);
17+
}
18+
}
19+
return ans;
20+
}

0 commit comments

Comments
 (0)