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 a4120c8

Browse files
Merge pull request SharingSource#790 from SharingSource/ac_oier
🌟 feat: add 1089、1178、1217、1224、1450、1713、1786、1818、1823、1846、1877、241、331、390、398、581、592、593、622、640、658、741、761、768、899、908
2 parents 5d280e6 + b32636e commit a4120c8

28 files changed

+1569
-194
lines changed

‎LeetCode/1081-1090/1089. 复写零(简单).md‎

Lines changed: 54 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,7 +53,7 @@ Tag : 「双指针」
5353

5454
> 这个往回赋值的过程,十分建议大家在纸上推导一遍。
5555
56-
代码:
56+
Java 代码:
5757
```Java
5858
class Solution {
5959
public void duplicateZeros(int[] arr) {
@@ -71,6 +71,59 @@ class Solution {
7171
}
7272
}
7373
```
74+
C++ 代码:
75+
```C++
76+
class Solution {
77+
public:
78+
void duplicateZeros(vector<int>& arr) {
79+
int n = arr.size(), i = 0, j = 0;
80+
while (j < n) {
81+
if (arr[i] == 0) j++;
82+
i++; j++;
83+
}
84+
i--; j--;
85+
while (i >= 0) {
86+
if (j < n) arr[j] = arr[i];
87+
if (arr[i] == 0 && --j >= 0) arr[j] = 0;
88+
i--; j--;
89+
}
90+
}
91+
};
92+
```
93+
Python 代码:
94+
```Python
95+
class Solution:
96+
def duplicateZeros(self, arr: List[int]) -> None:
97+
n, i, j = len(arr), 0, 0
98+
while j < n:
99+
if arr[i] == 0:
100+
j += 1
101+
i, j = i + 1, j + 1
102+
i, j = i - 1, j - 1
103+
while i >= 0:
104+
if j < n:
105+
arr[j] = arr[i]
106+
if arr[i] == 0 and j - 1 >= 0:
107+
j -= 1
108+
arr[j] = 0
109+
i, j = i - 1, j - 1
110+
```
111+
TypeScript 代码:
112+
```TypeScript
113+
function duplicateZeros(arr: number[]): void {
114+
let n = arr.length, i = 0, j = 0;
115+
while (j < n) {
116+
if (arr[i] == 0) j++;
117+
i++; j++;
118+
}
119+
i--; j--;
120+
while (i >= 0) {
121+
if (j < n) arr[j] = arr[i];
122+
if (arr[i] == 0 && --j >= 0) arr[j] = 0;
123+
i--; j--;
124+
}
125+
};
126+
```
74127
* 时间复杂度:$O(n)$
75128
* 空间复杂度:$O(1)$
76129

‎LeetCode/1171-1180/1178. 猜字谜(困难).md‎

Lines changed: 27 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -8,12 +8,13 @@ Tag : 「状态压缩」、「位运算」、「哈希表」
88

99
外国友人仿照中国字谜设计了一个英文版猜字谜小游戏,请你来猜猜看吧。
1010

11-
字谜的迷面 puzzle 按字符串形式给出,如果一个单词 word 符合下面两个条件,那么它就可以算作谜底:
12-
* 单词 word 中包含谜面 puzzle 的第一个字母。
13-
* 单词 word 中的每一个字母都可以在谜面 puzzle 中找到。
14-
例如,如果字谜的谜面是 "abcdefg",那么可以作为谜底的单词有 "faced", "cabbage", 和 "baggage";而 "beefed"(不含字母 "a")以及 "based"(其中的 "s" 没有出现在谜面中)都不能作为谜底。
11+
字谜的迷面 `puzzle` 按字符串形式给出,如果一个单词 `word` 符合下面两个条件,那么它就可以算作谜底:
12+
* 单词 `word` 中包含谜面 `puzzle` 的第一个字母。
13+
* 单词 `word` 中的每一个字母都可以在谜面 `puzzle` 中找到。
1514

16-
返回一个答案数组 answer,数组中的每个元素 answer[i] 是在给出的单词列表 words 中可以作为字谜迷面 puzzles[i] 所对应的谜底的单词数目。
15+
例如,如果字谜的谜面是 `"abcdefg"`,那么可以作为谜底的单词有 `"faced"`, `"cabbage"`, 和 `"baggage"`;而 `"beefed"`(不含字母 `"a"`)以及 `"based"`(其中的 `"s"` 没有出现在谜面中)都不能作为谜底。
16+
17+
返回一个答案数组 `answer`,数组中的每个元素 `answer[i]` 是在给出的单词列表 `words` 中可以作为字谜迷面 `puzzles[i]` 所对应的谜底的单词数目。
1718

1819

1920
示例:
@@ -32,16 +33,16 @@ puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
3233
```
3334

3435
提示:
35-
* 1 <= words.length <= $10^5$
36-
* 4 <= words[i].length <= 50
37-
* 1 <= puzzles.length <= $10^4$
38-
* puzzles[i].length == 7
39-
* words[i][j], puzzles[i][j] 都是小写英文字母。
40-
* 每个 puzzles[i] 所包含的字符都不重复。
36+
* $1 <= words.length <= 10^5$
37+
* $4 <= words[i].length <= 50$
38+
* $1 <= puzzles.length <= 10^4$
39+
* $puzzles[i].length = 7$
40+
* `words[i][j]`, `puzzles[i][j]` 都是小写英文字母
41+
* 每个 `puzzles[i]` 所包含的字符都不重复
4142

4243
---
4344

44-
### 朴素位运算解法(TLE)
45+
### 朴素位运算 (TLE)
4546

4647
根据「谜底」和「谜面」的对应条件:
4748
* 单词 `word` 中包含谜面 `puzzle` 的第一个字母。
@@ -55,8 +56,8 @@ puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
5556

5657
至此我们可以已经可以得出一个朴素解法的思路了:
5758

58-
1. 预处理除所有的 `word` 对应的二进制数字。计算量为 50 * $10^5,ドル数量级为 10ドル^6$
59-
2. 对每个 `puzzle` 进行条件判定(每一个 `puzzle` 都需要遍历所有的 `word` 进行检查)。计算量为 10ドル^5$ * $10^4,ドル数量级为 10ドル^9$
59+
1. 预处理除所有的 `word` 对应的二进制数字。计算量为 $50 \times 10^5,ドル数量级为 10ドル^6$
60+
2. 对每个 `puzzle` 进行条件判定(每一个 `puzzle` 都需要遍历所有的 `word` 进行检查)。计算量为 10ドル^5 \times 10^4,ドル数量级为 10ドル^9$
6061

6162
计算机单秒的计算量为 10ドル^7$ 左右(OJ 测评器通常在 10ドル^6$ ~ 10ドル^7$ 之间),哪怕忽略常数后,我们的总运算也超过了上限,铁定超时。
6263

@@ -102,12 +103,12 @@ class Solution {
102103
}
103104
}
104105
```
105-
* 时间复杂度:$O(words.length * (words[i].length + puzzles.length))$
106+
* 时间复杂度:$O(words.length \times (words[i].length + puzzles.length))$
106107
* 空间复杂度:每个 `word` 对应了一个 int,每个 `puzzle` 对应了一个答案。复杂度为 $O(words.length + puzzles.length)$
107108

108-
***
109+
---
109110

110-
### 哈希表 & 位运算解法
111+
### 哈希表 & 位运算
111112

112113
因此我们需要优化上述步骤 1 或者步骤 2 。显然超时的主要原因是步骤 2 计算量太多了。
113114

@@ -130,8 +131,8 @@ class Solution {
130131

131132
这样做的复杂度/计算量是多少呢?
132133

133-
1. 统计所有 `word` 的词频。计算量为 50 * $10^5,ドル数量级为 10ドル^6$
134-
2. 对应每个 `puzzle` 而言,由于其长度确定为 7,因此所有枚举所有可能「谜底」的数量不为 2ドル^6$=64 个,可以看做是 $O(1)$ 的,检查每个可能的「谜底」在 `words` 出现次数是通过哈希表,也是近似 $O(1)$ 的。因此在确定一个 `puzzle` 的答案时,与 `words` 的长度无关。计算量为 10ドル^4,ドル数量级为 10ドル^4$
134+
1. 统计所有 `word` 的词频。计算量为 $50 \times 10^5,ドル数量级为 10ドル^6$
135+
2. 对应每个 `puzzle` 而言,由于其长度确定为 7,因此所有枚举所有可能「谜底」的数量不为 2ドル^6=64$ 个,可以看做是 $O(1)$ 的,检查每个可能的「谜底」在 `words` 出现次数是通过哈希表,也是近似 $O(1)$ 的。因此在确定一个 `puzzle` 的答案时,与 `words` 的长度无关。计算量为 10ドル^4,ドル数量级为 10ドル^4$
135136

136137
计算机单秒的计算量为 10ドル^7$ 左右(OJ 测评器通常在 10ドル^6$ ~ 10ドル^7$ 之间),因此可以过。
137138

@@ -188,32 +189,28 @@ class Solution {
188189
}
189190
}
190191
```
191-
* 时间复杂度:$O(words.length * words[i].length + puzzles.length)$
192+
* 时间复杂度:$O(words.length \times words[i].length + puzzles.length)$
192193
* 空间复杂度:`word` 和 `puzzle` 分别具有最大长度和固定长度,使用空间主要取决于量数组的长度。复杂度为 $O(words.length + puzzles.length)$
193194

194-
***
195+
---
195196

196197
### 位运算说明
197198

198-
a >> b & 1 代表检查 a 的第 b 位是否为 1,有两种可能性 0 或者 1
199+
`a >> b & 1` 代表检查 `a` 的第 `b` 位是否为 1,有两种可能性 0 或者 1
199200

200-
a += 1 << b 代表将 a 的第 b 位设置为 1 (当第 b 位为 0 的时候适用)
201+
`a += 1 << b` 代表将 `a` 的第 `b` 位设置为 1 (当第 `b` 位为 0 的时候适用)
201202

202-
如不想写对第 b 位为 0 的前置判断,a += 1 << b 也可以改成 a |= 1 << b
203+
如不想写对第 `b` 位为 `0` 的前置判断,`a += 1 << b` 也可以改成 `a |= 1 << b`
203204

204-
*PS. 1 的二进制就是最低位为 1,其他位为 0 哦*
205-
206-
以上两个操作在位运算中出现频率超高,建议每位同学都加深理解。
207-
208-
***
205+
---
209206

210207
### 点评
211208

212209
这道题解发到 LeetCode 之后,很多同学反映还是看不懂,还是不理解。
213210

214211
于是我重新的思考了这道题的每一个环节。
215212

216-
这道题之所是 Hard,是因为考察的都是违反人性"直觉"的东西:
213+
这道题之所是 Hard,是因为考察的都是违反人性"直觉"的东西:
217214

218215
1. 状态压缩:对一个单词出现过哪些字母,不能采用我们直观中的 map/set 进行记录,而要利用一个长度为 26 的二进制数来记录,对于某个字母需要计算在二进制数中的哪一位,如果出现过用 1 表示,没出现过用 0 表示
219216
2. 正难则反:不能从 `words` 数组出发,去检查有哪些 `word` 符合要求;而要反过来从 `puzzle` 出发,去枚举当前 `puzzle` 所有合法的 `word`,再去确定这些合法的 `word` 在真实的 `words` 数组中出现了多少次

‎LeetCode/1211-1220/1217. 玩筹码(简单).md‎

Lines changed: 79 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -6,14 +6,16 @@ Tag : 「贪心」、「枚举」
66

77

88

9-
有 `n` 个筹码。第 $i$ 个筹码的位置是 `position[i]`。
9+
有 `n` 个筹码,第 $i$ 个筹码的位置是 `position[i]`。
1010

11-
我们需要把所有筹码移到同一个位置。在一步中,我们可以将第 $i$ 个筹码的位置从 $position[i]$ 改变为:
11+
我们需要把所有筹码移到同一个位置。
12+
13+
在一步中,我们可以将第 $i$ 个筹码的位置从 $position[i]$ 改变为:
1214

1315
* `position[i] + 2 或 position[i] - 2`,此时 `cost = 0`
1416
* `position[i] + 1 或 position[i] - 1`,此时 `cost = 1`
1517

16-
返回将所有筹码移动到同一位置上所需要的 最小代价 。
18+
返回将所有筹码移动到同一位置上所需要的最小代价。
1719

1820
示例 1:
1921
![](https://assets.leetcode.com/uploads/2020/08/15/chips_e1.jpg)
@@ -60,7 +62,7 @@ Tag : 「贪心」、「枚举」
6062

6163
综上,我们可以枚举所有已有的位置为目标位置,并通过奇偶性统计其余位置到目标位置的成本,在所有已有位置中取最小的总成本即是答案。
6264

63-
代码:
65+
Java 代码:
6466
```Java
6567
class Solution {
6668
public int minCostToMoveChips(int[] ps) {
@@ -77,6 +79,52 @@ class Solution {
7779
}
7880
}
7981
```
82+
C++ 代码:
83+
```C++
84+
class Solution {
85+
public:
86+
int minCostToMoveChips(vector<int>& ps) {
87+
int n = ps.size(), ans = numeric_limits<int>::max();
88+
for (int i = 0; i < n; i++) {
89+
int a = ps[i], cur = 0;
90+
for (int j = 0; j < n; j++) {
91+
int b = ps[j];
92+
cur += abs(a - b) % 2;
93+
}
94+
ans = min(ans, cur);
95+
}
96+
return ans;
97+
}
98+
};
99+
```
100+
Python 代码:
101+
```Python
102+
class Solution:
103+
def minCostToMoveChips(self, ps: List[int]) -> int:
104+
n, ans = len(ps), float('inf')
105+
for i in range(n):
106+
a, cur = ps[i], 0
107+
for j in range(n):
108+
b = ps[j]
109+
cur += abs(a - b) % 2
110+
ans = min(ans, cur)
111+
return ans
112+
```
113+
TypeScript 代码:
114+
```TypeScript
115+
function minCostToMoveChips(ps: number[]): number {
116+
let n = ps.length, ans = 0x3f3f3f3f;
117+
for (let i = 0; i < n; i++) {
118+
let a = ps[i], cur = 0;
119+
for (let j = 0; j < n; j++) {
120+
const b = ps[j];
121+
cur += Math.abs(a - b) % 2;
122+
}
123+
ans = Math.min(ans, cur);
124+
}
125+
return ans;
126+
};
127+
```
80128
* 时间复杂度:$O(n^2)$
81129
* 空间复杂度:$O(1)$
82130

@@ -88,7 +136,7 @@ class Solution {
88136

89137
因此我们可以省去枚举具体位置的操作,转而统计原有数的奇偶位置个数,假设偶数位置有 $a$ 个,奇数位置有 $b$ 个,最终目标位置选为偶数的成本为 $b,ドル最终目标位置选为奇数的成本为 $a,ドル即两者中的最小值即是答案。
90138

91-
代码:
139+
Java 代码:
92140
```Java
93141
class Solution {
94142
public int minCostToMoveChips(int[] ps) {
@@ -98,6 +146,32 @@ class Solution {
98146
}
99147
}
100148
```
149+
C++ 代码:
150+
```C++
151+
class Solution {
152+
public:
153+
int minCostToMoveChips(vector<int>& ps) {
154+
int n = ps.size(), a = 0;
155+
for (int i : ps) a += i % 2;
156+
return min(a, n - a);
157+
}
158+
};
159+
```
160+
Python 代码:
161+
```Python
162+
class Solution:
163+
def minCostToMoveChips(self, ps: List[int]) -> int:
164+
n, a = len(ps), sum(x % 2 for x in ps)
165+
return min(a, n - a)
166+
```
167+
TypeScript 代码:
168+
```TypeScript
169+
function minCostToMoveChips(ps: number[]): number {
170+
const n = ps.length;
171+
let a = ps.filter(x => x % 2 === 1).length;
172+
return Math.min(a, n - a);
173+
};
174+
```
101175
* 时间复杂度:$O(n)$
102176
* 空间复杂度:$O(1)$
103177

‎LeetCode/1221-1230/1224. 最大相等频率(困难).md‎

Lines changed: 37 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ Tag : 「模拟」、「哈希表」、「计数」
88

99
给你一个正整数数组 `nums`,请你帮忙从该数组中找出能满足下面要求的最长前缀,并返回该前缀的长度:
1010

11-
* 从前缀中 恰好删除一个 元素后,剩下每个数字的出现次数都相同。
11+
* 从前缀中恰好删除一个元素后,剩下每个数字的出现次数都相同。
1212

1313
如果删除这个元素后没有剩余元素存在,仍可认为每个数字都具有相同的出现次数(也就是 0ドル$ 次)。
1414

@@ -62,6 +62,42 @@ class Solution {
6262
}
6363
}
6464
```
65+
C++ 代码:
66+
```C++
67+
class Solution {
68+
public:
69+
int maxEqualFreq(vector<int>& nums) {
70+
vector<int> cnt(100010, 0), sumv(100010, 0);
71+
int n = nums.size(), maxv = 0, ans = 0;
72+
for (int i = 0; i < n; i++) {
73+
int t = nums[i], cur = ++cnt[t], len = i + 1;
74+
sumv[cur]++; sumv[cur - 1]--;
75+
maxv = max(maxv, cur);
76+
if (maxv == 1) ans = len;
77+
if (maxv * sumv[maxv] + 1 == len) ans = len;
78+
if ((maxv - 1) * (sumv[maxv - 1] + 1) + 1 == len) ans = len;
79+
}
80+
return ans;
81+
}
82+
};
83+
```
84+
Python 代码:
85+
```Python
86+
class Solution:
87+
def maxEqualFreq(self, nums: List[int]) -> int:
88+
cnt, sumv = [0] * 100010, [0] * 100010
89+
n, maxv, ans = len(nums), 0, 0
90+
for i, t in enumerate(nums):
91+
cur, lenv = cnt[nums[i]] + 1, i + 1
92+
cnt[t] += 1
93+
sumv[cur] += 1
94+
sumv[cur - 1] -= 1
95+
maxv = max(maxv, cur)
96+
if maxv == 1: ans = lenv
97+
if maxv * sumv[maxv] + 1 == lenv: ans = lenv
98+
if (maxv - 1) * (sumv[maxv - 1] + 1) + 1 == lenv: ans = lenv
99+
return ans
100+
```
65101
TypeScript 代码:
66102
```TypeScript
67103
function maxEqualFreq(nums: number[]): number {

‎LeetCode/1441-1450/1450. 在既定时间做作业的学生人数(简单).md‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,32 @@ class Solution {
8383
}
8484
}
8585
```
86+
C++ 代码:
87+
```C++
88+
class Solution {
89+
public:
90+
int busyStudent(vector<int>& st, vector<int>& et, int t) {
91+
vector<int> c(1010, 0);
92+
for (int i = 0; i < st.size(); i++) {
93+
c[st[i]] += 1; c[et[i] + 1] -= 1;
94+
}
95+
for (int i = 1; i <= t; ++i) c[i] += c[i - 1];
96+
return c[t];
97+
}
98+
};
99+
```
100+
Python 代码:
101+
```Python
102+
class Solution:
103+
def busyStudent(self, st: List[int], et: List[int], t: int) -> int:
104+
c = [0] * 1010
105+
for i in range(len(st)):
106+
c[st[i]] += 1
107+
c[et[i] + 1] -= 1
108+
for i in range(t + 1):
109+
c[i] += c[i - 1]
110+
return c[t]
111+
```
86112
TypeScript 代码:
87113
```TypeScript
88114
function busyStudent(st: number[], et: number[], t: number): number {

0 commit comments

Comments
(0)

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