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 29339f4

Browse files
feat: add solutions to lc problem: No.3003 (doocs#2202)
No.3003.Maximize the Number of Partitions After Operations
1 parent 433c046 commit 29339f4

File tree

7 files changed

+515
-6
lines changed

7 files changed

+515
-6
lines changed

‎solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README.md‎

Lines changed: 173 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -90,27 +90,197 @@ s 变为 "xayz"。
9090
<!-- 这里可写当前语言的特殊实现逻辑 -->
9191

9292
```python
93-
93+
class Solution:
94+
def maxPartitionsAfterOperations(self, s: str, k: int) -> int:
95+
@cache
96+
def dfs(i: int, cur: int, t: int) -> int:
97+
if i >= n:
98+
return 1
99+
v = 1 << (ord(s[i]) - ord("a"))
100+
nxt = cur | v
101+
if nxt.bit_count() > k:
102+
ans = dfs(i + 1, v, t) + 1
103+
else:
104+
ans = dfs(i + 1, nxt, t)
105+
if t:
106+
for j in range(26):
107+
nxt = cur | (1 << j)
108+
if nxt.bit_count() > k:
109+
ans = max(ans, dfs(i + 1, 1 << j, 0) + 1)
110+
else:
111+
ans = max(ans, dfs(i + 1, nxt, 0))
112+
return ans
113+
114+
n = len(s)
115+
return dfs(0, 0, 1)
94116
```
95117

96118
### **Java**
97119

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

100122
```java
101-
123+
class Solution {
124+
private Map<List<Integer>, Integer> f = new HashMap<>();
125+
private String s;
126+
private int k;
127+
128+
public int maxPartitionsAfterOperations(String s, int k) {
129+
this.s = s;
130+
this.k = k;
131+
return dfs(0, 0, 1);
132+
}
133+
134+
private int dfs(int i, int cur, int t) {
135+
if (i >= s.length()) {
136+
return 1;
137+
}
138+
var key = List.of(i, cur, t);
139+
if (f.containsKey(key)) {
140+
return f.get(key);
141+
}
142+
int v = 1 << (s.charAt(i) - 'a');
143+
int nxt = cur | v;
144+
int ans = Integer.bitCount(nxt) > k ? dfs(i + 1, v, t) + 1 : dfs(i + 1, nxt, t);
145+
if (t > 0) {
146+
for (int j = 0; j < 26; ++j) {
147+
nxt = cur | (1 << j);
148+
if (Integer.bitCount(nxt) > k) {
149+
ans = Math.max(ans, dfs(i + 1, 1 << j, 0) + 1);
150+
} else {
151+
ans = Math.max(ans, dfs(i + 1, nxt, 0));
152+
}
153+
}
154+
}
155+
f.put(key, ans);
156+
return ans;
157+
}
158+
}
102159
```
103160

104161
### **C++**
105162

106163
```cpp
107-
164+
class Solution {
165+
public:
166+
int maxPartitionsAfterOperations(string s, int k) {
167+
int n = s.size();
168+
unordered_map<long long, int> f;
169+
function<int(int, int, int)> dfs = [&](int i, int cur, int t) {
170+
if (i >= n) {
171+
return 1;
172+
}
173+
long long key = (long long) i << 32 | cur << 1 | t;
174+
if (f.count(key)) {
175+
return f[key];
176+
}
177+
int v = 1 << (s[i] - 'a');
178+
int nxt = cur | v;
179+
int ans = __builtin_popcount(nxt) > k ? dfs(i + 1, v, t) + 1 : dfs(i + 1, nxt, t);
180+
if (t) {
181+
for (int j = 0; j < 26; ++j) {
182+
nxt = cur | (1 << j);
183+
if (__builtin_popcount(nxt) > k) {
184+
ans = max(ans, dfs(i + 1, 1 << j, 0) + 1);
185+
} else {
186+
ans = max(ans, dfs(i + 1, nxt, 0));
187+
}
188+
}
189+
}
190+
return f[key] = ans;
191+
};
192+
return dfs(0, 0, 1);
193+
}
194+
};
108195
```
109196
110197
### **Go**
111198
112199
```go
200+
func maxPartitionsAfterOperations(s string, k int) int {
201+
n := len(s)
202+
type tuple struct{ i, cur, t int }
203+
f := map[tuple]int{}
204+
var dfs func(i, cur, t int) int
205+
dfs = func(i, cur, t int) int {
206+
if i >= n {
207+
return 1
208+
}
209+
key := tuple{i, cur, t}
210+
if v, ok := f[key]; ok {
211+
return v
212+
}
213+
v := 1 << (s[i] - 'a')
214+
nxt := cur | v
215+
var ans int
216+
if bits.OnesCount(uint(nxt)) > k {
217+
ans = dfs(i+1, v, t) + 1
218+
} else {
219+
ans = dfs(i+1, nxt, t)
220+
}
221+
if t > 0 {
222+
for j := 0; j < 26; j++ {
223+
nxt = cur | (1 << j)
224+
if bits.OnesCount(uint(nxt)) > k {
225+
ans = max(ans, dfs(i+1, 1<<j, 0)+1)
226+
} else {
227+
ans = max(ans, dfs(i+1, nxt, 0))
228+
}
229+
}
230+
}
231+
f[key] = ans
232+
return ans
233+
}
234+
return dfs(0, 0, 1)
235+
}
236+
```
113237

238+
### **TypeScript**
239+
240+
```ts
241+
function maxPartitionsAfterOperations(s: string, k: number): number {
242+
const n = s.length;
243+
const f: Map<bigint, number> = new Map();
244+
const dfs = (i: number, cur: number, t: number): number => {
245+
if (i >= n) {
246+
return 1;
247+
}
248+
const key = (BigInt(i) << 27n) | (BigInt(cur) << 1n) | BigInt(t);
249+
if (f.has(key)) {
250+
return f.get(key)!;
251+
}
252+
const v = 1 << (s.charCodeAt(i) - 97);
253+
let nxt = cur | v;
254+
let ans = 0;
255+
if (bitCount(nxt) > k) {
256+
ans = dfs(i + 1, v, t) + 1;
257+
} else {
258+
ans = dfs(i + 1, nxt, t);
259+
}
260+
if (t) {
261+
for (let j = 0; j < 26; ++j) {
262+
nxt = cur | (1 << j);
263+
if (bitCount(nxt) > k) {
264+
ans = Math.max(ans, dfs(i + 1, 1 << j, 0) + 1);
265+
} else {
266+
ans = Math.max(ans, dfs(i + 1, nxt, 0));
267+
}
268+
}
269+
}
270+
f.set(key, ans);
271+
return ans;
272+
};
273+
return dfs(0, 0, 1);
274+
}
275+
276+
function bitCount(i: number): number {
277+
i = i - ((i >>> 1) & 0x55555555);
278+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
279+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
280+
i = i + (i >>> 8);
281+
i = i + (i >>> 16);
282+
return i & 0x3f;
283+
}
114284
```
115285

116286
### **...**

‎solution/3000-3099/3003.Maximize the Number of Partitions After Operations/README_EN.md‎

Lines changed: 173 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -83,25 +83,195 @@ It can be shown that it is not possible to obtain more than 4 partitions.
8383
### **Python3**
8484

8585
```python
86-
86+
class Solution:
87+
def maxPartitionsAfterOperations(self, s: str, k: int) -> int:
88+
@cache
89+
def dfs(i: int, cur: int, t: int) -> int:
90+
if i >= n:
91+
return 1
92+
v = 1 << (ord(s[i]) - ord("a"))
93+
nxt = cur | v
94+
if nxt.bit_count() > k:
95+
ans = dfs(i + 1, v, t) + 1
96+
else:
97+
ans = dfs(i + 1, nxt, t)
98+
if t:
99+
for j in range(26):
100+
nxt = cur | (1 << j)
101+
if nxt.bit_count() > k:
102+
ans = max(ans, dfs(i + 1, 1 << j, 0) + 1)
103+
else:
104+
ans = max(ans, dfs(i + 1, nxt, 0))
105+
return ans
106+
107+
n = len(s)
108+
return dfs(0, 0, 1)
87109
```
88110

89111
### **Java**
90112

91113
```java
92-
114+
class Solution {
115+
private Map<List<Integer>, Integer> f = new HashMap<>();
116+
private String s;
117+
private int k;
118+
119+
public int maxPartitionsAfterOperations(String s, int k) {
120+
this.s = s;
121+
this.k = k;
122+
return dfs(0, 0, 1);
123+
}
124+
125+
private int dfs(int i, int cur, int t) {
126+
if (i >= s.length()) {
127+
return 1;
128+
}
129+
var key = List.of(i, cur, t);
130+
if (f.containsKey(key)) {
131+
return f.get(key);
132+
}
133+
int v = 1 << (s.charAt(i) - 'a');
134+
int nxt = cur | v;
135+
int ans = Integer.bitCount(nxt) > k ? dfs(i + 1, v, t) + 1 : dfs(i + 1, nxt, t);
136+
if (t > 0) {
137+
for (int j = 0; j < 26; ++j) {
138+
nxt = cur | (1 << j);
139+
if (Integer.bitCount(nxt) > k) {
140+
ans = Math.max(ans, dfs(i + 1, 1 << j, 0) + 1);
141+
} else {
142+
ans = Math.max(ans, dfs(i + 1, nxt, 0));
143+
}
144+
}
145+
}
146+
f.put(key, ans);
147+
return ans;
148+
}
149+
}
93150
```
94151

95152
### **C++**
96153

97154
```cpp
98-
155+
class Solution {
156+
public:
157+
int maxPartitionsAfterOperations(string s, int k) {
158+
int n = s.size();
159+
unordered_map<long long, int> f;
160+
function<int(int, int, int)> dfs = [&](int i, int cur, int t) {
161+
if (i >= n) {
162+
return 1;
163+
}
164+
long long key = (long long) i << 32 | cur << 1 | t;
165+
if (f.count(key)) {
166+
return f[key];
167+
}
168+
int v = 1 << (s[i] - 'a');
169+
int nxt = cur | v;
170+
int ans = __builtin_popcount(nxt) > k ? dfs(i + 1, v, t) + 1 : dfs(i + 1, nxt, t);
171+
if (t) {
172+
for (int j = 0; j < 26; ++j) {
173+
nxt = cur | (1 << j);
174+
if (__builtin_popcount(nxt) > k) {
175+
ans = max(ans, dfs(i + 1, 1 << j, 0) + 1);
176+
} else {
177+
ans = max(ans, dfs(i + 1, nxt, 0));
178+
}
179+
}
180+
}
181+
return f[key] = ans;
182+
};
183+
return dfs(0, 0, 1);
184+
}
185+
};
99186
```
100187
101188
### **Go**
102189
103190
```go
191+
func maxPartitionsAfterOperations(s string, k int) int {
192+
n := len(s)
193+
type tuple struct{ i, cur, t int }
194+
f := map[tuple]int{}
195+
var dfs func(i, cur, t int) int
196+
dfs = func(i, cur, t int) int {
197+
if i >= n {
198+
return 1
199+
}
200+
key := tuple{i, cur, t}
201+
if v, ok := f[key]; ok {
202+
return v
203+
}
204+
v := 1 << (s[i] - 'a')
205+
nxt := cur | v
206+
var ans int
207+
if bits.OnesCount(uint(nxt)) > k {
208+
ans = dfs(i+1, v, t) + 1
209+
} else {
210+
ans = dfs(i+1, nxt, t)
211+
}
212+
if t > 0 {
213+
for j := 0; j < 26; j++ {
214+
nxt = cur | (1 << j)
215+
if bits.OnesCount(uint(nxt)) > k {
216+
ans = max(ans, dfs(i+1, 1<<j, 0)+1)
217+
} else {
218+
ans = max(ans, dfs(i+1, nxt, 0))
219+
}
220+
}
221+
}
222+
f[key] = ans
223+
return ans
224+
}
225+
return dfs(0, 0, 1)
226+
}
227+
```
104228

229+
### **TypeScript**
230+
231+
```ts
232+
function maxPartitionsAfterOperations(s: string, k: number): number {
233+
const n = s.length;
234+
const f: Map<bigint, number> = new Map();
235+
const dfs = (i: number, cur: number, t: number): number => {
236+
if (i >= n) {
237+
return 1;
238+
}
239+
const key = (BigInt(i) << 27n) | (BigInt(cur) << 1n) | BigInt(t);
240+
if (f.has(key)) {
241+
return f.get(key)!;
242+
}
243+
const v = 1 << (s.charCodeAt(i) - 97);
244+
let nxt = cur | v;
245+
let ans = 0;
246+
if (bitCount(nxt) > k) {
247+
ans = dfs(i + 1, v, t) + 1;
248+
} else {
249+
ans = dfs(i + 1, nxt, t);
250+
}
251+
if (t) {
252+
for (let j = 0; j < 26; ++j) {
253+
nxt = cur | (1 << j);
254+
if (bitCount(nxt) > k) {
255+
ans = Math.max(ans, dfs(i + 1, 1 << j, 0) + 1);
256+
} else {
257+
ans = Math.max(ans, dfs(i + 1, nxt, 0));
258+
}
259+
}
260+
}
261+
f.set(key, ans);
262+
return ans;
263+
};
264+
return dfs(0, 0, 1);
265+
}
266+
267+
function bitCount(i: number): number {
268+
i = i - ((i >>> 1) & 0x55555555);
269+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
270+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
271+
i = i + (i >>> 8);
272+
i = i + (i >>> 16);
273+
return i & 0x3f;
274+
}
105275
```
106276

107277
### **...**

0 commit comments

Comments
(0)

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