Skip to content

Commit ca22a43

Browse files
yanglbmeyanglbme
authored
feat: add new lc problems and solutions (#1569)
* No.2839.Check if Strings Can be Made Equal With Operations I * No.2840.Check if Strings Can be Made Equal With Operations II * No.2841.Maximum Sum of Almost Unique Subarray * No.2842.Count K-Subsequences of a String With Maximum Beauty * No.2843.Count Symmetric Integers * No.2844.Minimum Operations to Make a Special Number * No.2845.Count of Interesting Subarrays * No.2846.Minimum Edge Weight Equilibrium Queries in a Tree
1 parent a83edac commit ca22a43

File tree

60 files changed

+3931
-61
lines changed

Some content is hidden

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

60 files changed

+3931
-61
lines changed

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/README.md

+30-29
Original file line numberDiff line numberDiff line change
@@ -68,15 +68,17 @@
6868

6969
**方法一：排序 + 贪心**
7070

71-
用 $times$ 数组记录每个怪物最晚可被消灭的时间。对于第 $i$ 个怪物，最晚可被消灭的时间满足：
71+
我们用 $times$ 数组记录每个怪物最晚可被消灭的时间。对于第 $i$ 个怪物，最晚可被消灭的时间满足：
7272

7373
$$times[i] = \lfloor \frac{dist[i]-1}{speed[i]} \rfloor$$
7474

75-
我们对 $times$ 数组升序排列，然后遍历 $times$ 数组。对于第 $i$ 个怪物，如果 $times[i] \geq i$，说明第 $i$ 个怪物可以被消灭，否则说明第 $i$ 个怪物无法被消灭，直接返回 $i$ 即可。
75+
接下来，我们对 $times$ 数组升序排列。
76+
77+
然后遍历 $times$ 数组，对于第 $i$ 个怪物，如果 $times[i] \geq i$，说明第 $i$ 个怪物可以被消灭，否则说明第 $i$ 个怪物无法被消灭，直接返回 $i$ 即可。
7678

7779
若所有怪物都可以被消灭，则返回 $n$。
7880

79-
时间复杂度 $O(nlogn)$。
81+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是数组的长度。
8082

8183
<!-- tabs:start -->
8284

@@ -87,12 +89,11 @@ $$times[i] = \lfloor \frac{dist[i]-1}{speed[i]} \rfloor$$
8789
```python
8890
class Solution:
8991
def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
90-
times = [(d - 1) // s for d, s in zip(dist, speed)]
91-
times.sort()
92+
times = sorted((d - 1) // s for d, s in zip(dist, speed))
9293
for i, t in enumerate(times):
9394
if t < i:
9495
return i
95-
return len(dist)
96+
return len(times)
9697
```
9798

9899
### **Java**
@@ -118,29 +119,6 @@ class Solution {
118119
}
119120
```
120121

121-
### **JavaScript**
122-
123-
```js
124-
/**
125-
* @param {number[]} dist
126-
* @param {number[]} speed
127-
* @return {number}
128-
*/
129-
var eliminateMaximum = function (dist, speed) {
130-
let arr = [];
131-
for (let i = 0; i < dist.length; i++) {
132-
arr[i] = dist[i] / speed[i];
133-
}
134-
arr.sort((a, b) => a - b);
135-
let ans = 0;
136-
while (arr[0] > ans) {
137-
arr.shift();
138-
++ans;
139-
}
140-
return ans;
141-
};
142-
```
143-
144122
### **C++**
145123

146124
```cpp
@@ -201,6 +179,29 @@ function eliminateMaximum(dist: number[], speed: number[]): number {
201179
}
202180
```
203181

182+
### **JavaScript**
183+
184+
```js
185+
/**
186+
* @param {number[]} dist
187+
* @param {number[]} speed
188+
* @return {number}
189+
*/
190+
var eliminateMaximum = function (dist, speed) {
191+
let arr = [];
192+
for (let i = 0; i < dist.length; i++) {
193+
arr[i] = dist[i] / speed[i];
194+
}
195+
arr.sort((a, b) => a - b);
196+
let ans = 0;
197+
while (arr[0] > ans) {
198+
arr.shift();
199+
++ans;
200+
}
201+
return ans;
202+
};
203+
```
204+
204205
### **...**
205206

206207
```

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/README_EN.md

+25-26
Original file line numberDiff line numberDiff line change
@@ -66,12 +66,11 @@ You can only eliminate 1 monster.
6666
```python
6767
class Solution:
6868
def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
69-
times = [(d - 1) // s for d, s in zip(dist, speed)]
70-
times.sort()
69+
times = sorted((d - 1) // s for d, s in zip(dist, speed))
7170
for i, t in enumerate(times):
7271
if t < i:
7372
return i
74-
return len(dist)
73+
return len(times)
7574
```
7675

7776
### **Java**
@@ -95,29 +94,6 @@ class Solution {
9594
}
9695
```
9796

98-
### **JavaScript**
99-
100-
```js
101-
/**
102-
* @param {number[]} dist
103-
* @param {number[]} speed
104-
* @return {number}
105-
*/
106-
var eliminateMaximum = function (dist, speed) {
107-
let arr = [];
108-
for (let i = 0; i < dist.length; i++) {
109-
arr[i] = dist[i] / speed[i];
110-
}
111-
arr.sort((a, b) => a - b);
112-
let ans = 0;
113-
while (arr[0] > ans) {
114-
arr.shift();
115-
++ans;
116-
}
117-
return ans;
118-
};
119-
```
120-
12197
### **C++**
12298

12399
```cpp
@@ -178,6 +154,29 @@ function eliminateMaximum(dist: number[], speed: number[]): number {
178154
}
179155
```
180156

157+
### **JavaScript**
158+
159+
```js
160+
/**
161+
* @param {number[]} dist
162+
* @param {number[]} speed
163+
* @return {number}
164+
*/
165+
var eliminateMaximum = function (dist, speed) {
166+
let arr = [];
167+
for (let i = 0; i < dist.length; i++) {
168+
arr[i] = dist[i] / speed[i];
169+
}
170+
arr.sort((a, b) => a - b);
171+
let ans = 0;
172+
while (arr[0] > ans) {
173+
arr.shift();
174+
++ans;
175+
}
176+
return ans;
177+
};
178+
```
179+
181180
### **...**
182181

183182
```

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/Solution.py

+4-6
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,7 @@
11
class Solution:
22
def eliminateMaximum(self, dist: List[int], speed: List[int]) -> int:
3-
n = len(dist)
4-
times = [(dist[i] - 1) // speed[i] for i in range(n)]
5-
times.sort()
6-
for i in range(n):
7-
if times[i] < i:
3+
times = sorted((d - 1) // s for d, s in zip(dist, speed))
4+
for i, t in enumerate(times):
5+
if t < i:
86
return i
9-
return n
7+
return len(times)

‎solution/2800-2899/2839.Check if Strings Can be Made Equal With Operations I/README.md

+151
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,151 @@
1+
# [2839. 判断通过操作能否让字符串相等 I](https://leetcode.cn/problems/check-if-strings-can-be-made-equal-with-operations-i)
2+
3+
[English Version](/solution/2800-2899/2839.Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20I/README_EN.md)
4+
5+
## 题目描述
6+
7+
<!-- 这里写题目描述 -->
8+
9+
<p>给你两个字符串&nbsp;<code>s1</code> 和&nbsp;<code>s2</code>&nbsp;，两个字符串的长度都为&nbsp;<code>4</code>&nbsp;，且只包含 <strong>小写</strong> 英文字母。</p>
10+
11+
<p>你可以对两个字符串中的 <strong>任意一个</strong>&nbsp;执行以下操作 <strong>任意</strong>&nbsp;次：</p>
12+
13+
<ul>
14+
<li>选择两个下标&nbsp;<code>i</code> 和&nbsp;<code>j</code>&nbsp;且满足&nbsp;<code>j - i = 2</code>&nbsp;，然后 <strong>交换</strong> 这个字符串中两个下标对应的字符。</li>
15+
</ul>
16+
17+
<p>如果你可以让字符串<em>&nbsp;</em><code>s1</code><em> </em>和<em>&nbsp;</em><code>s2</code>&nbsp;相等，那么返回 <code>true</code>&nbsp;，否则返回 <code>false</code>&nbsp;。</p>
18+
19+
<p>&nbsp;</p>
20+
21+
<p><strong class="example">示例 1：</strong></p>
22+
23+
<pre>
24+
<b>输入：</b>s1 = "abcd", s2 = "cdab"
25+
<b>输出：</b>true
26+
<strong>解释：</strong> 我们可以对 s1 执行以下操作：
27+
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbad" 。
28+
- 选择下标 i = 1 ，j = 3 ，得到字符串 s1 = "cdab" = s2 。
29+
</pre>
30+
31+
<p><strong class="example">示例 2：</strong></p>
32+
33+
<pre>
34+
<b>输入：</b>s1 = "abcd", s2 = "dacb"
35+
<b>输出：</b>false
36+
<b>解释：</b>无法让两个字符串相等。
37+
</pre>
38+
39+
<p>&nbsp;</p>
40+
41+
<p><strong>提示：</strong></p>
42+
43+
<ul>
44+
<li><code>s1.length == s2.length == 4</code></li>
45+
<li><code>s1</code> 和&nbsp;<code>s2</code>&nbsp;只包含小写英文字母。</li>
46+
</ul>
47+
48+
## 解法
49+
50+
<!-- 这里可写通用的实现逻辑 -->
51+
52+
<!-- tabs:start -->
53+
54+
### **Python3**
55+
56+
<!-- 这里可写当前语言的特殊实现逻辑 -->
57+
58+
```python
59+
class Solution:
60+
def canBeEqual(self, s1: str, s2: str) -> bool:
61+
return sorted(s1[::2]) == sorted(s2[::2]) and sorted(s1[1::2]) == sorted(
62+
s2[1::2]
63+
)
64+
```
65+
66+
### **Java**
67+
68+
<!-- 这里可写当前语言的特殊实现逻辑 -->
69+
70+
```java
71+
class Solution {
72+
public boolean canBeEqual(String s1, String s2) {
73+
int[][] cnt = new int[2][26];
74+
for (int i = 0; i < s1.length(); ++i) {
75+
++cnt[i & 1][s1.charAt(i) - 'a'];
76+
--cnt[i & 1][s2.charAt(i) - 'a'];
77+
}
78+
for (int i = 0; i < 26; ++i) {
79+
if (cnt[0][i] != 0 || cnt[1][i] != 0) {
80+
return false;
81+
}
82+
}
83+
return true;
84+
}
85+
}
86+
```
87+
88+
### **C++**
89+
90+
```cpp
91+
class Solution {
92+
public:
93+
bool canBeEqual(string s1, string s2) {
94+
vector<vector<int>> cnt(2, vector<int>(26, 0));
95+
for (int i = 0; i < s1.size(); ++i) {
96+
++cnt[i & 1][s1[i] - 'a'];
97+
--cnt[i & 1][s2[i] - 'a'];
98+
}
99+
for (int i = 0; i < 26; ++i) {
100+
if (cnt[0][i] || cnt[1][i]) {
101+
return false;
102+
}
103+
}
104+
return true;
105+
}
106+
};
107+
```
108+
109+
### **Go**
110+
111+
```go
112+
func canBeEqual(s1 string, s2 string) bool {
113+
cnt := [2][26]int{}
114+
for i := 0; i < len(s1); i++ {
115+
cnt[i&1][s1[i]-'a']++
116+
cnt[i&1][s2[i]-'a']--
117+
}
118+
for i := 0; i < 26; i++ {
119+
if cnt[0][i] != 0 || cnt[1][i] != 0 {
120+
return false
121+
}
122+
}
123+
return true
124+
}
125+
```
126+
127+
### **TypeScript**
128+
129+
```ts
130+
function canBeEqual(s1: string, s2: string): boolean {
131+
const cnt: number[][] = Array.from({ length: 2 }, () => Array.from({ length: 26 }, () => 0));
132+
for (let i = 0; i < s1.length; ++i) {
133+
++cnt[i & 1][s1.charCodeAt(i) - 97];
134+
--cnt[i & 1][s2.charCodeAt(i) - 97];
135+
}
136+
for (let i = 0; i < 26; ++i) {
137+
if (cnt[0][i] || cnt[1][i]) {
138+
return false;
139+
}
140+
}
141+
return true;
142+
}
143+
```
144+
145+
### **...**
146+
147+
```
148+
149+
```
150+
151+
<!-- tabs:end -->

0 commit comments

Comments
 (0)