Skip to content

Commit 29339f4

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3003 (#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)