Skip to content

Commit 8fa590a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0474.Ones and Zeroes
1 parent 733ef7a commit 8fa590a

File tree

6 files changed

+324
-0
lines changed

6 files changed

+324
-0
lines changed

‎solution/0400-0499/0474.Ones and Zeroes/README.md

+119
Original file line numberDiff line numberDiff line change
@@ -49,22 +49,141 @@
4949

5050
<!-- 这里可写通用的实现逻辑 -->
5151

52+
题目可以转换为 `0-1` 背包问题，在 k 个字符串中选出一些字符串（每个字符串只能使用一次），并且满足字符串最多包含 m 个 0 和 n 个 1，求满足此条件的字符串的最大长度（字符串个数）。
53+
5254
<!-- tabs:start -->
5355

5456
### **Python3**
5557

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

5860
```python
61+
class Solution:
62+
def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
63+
l = len(strs)
64+
dp = [[[0] * (n + 1) for i in range(m + 1)] for j in range(l)]
65+
t = [(s.count('0'), s.count('1')) for s in strs]
66+
n0, n1 = t[0]
67+
for j in range(m + 1):
68+
for k in range(n + 1):
69+
if n0 <= j and n1 <= k:
70+
dp[0][j][k] = 1
71+
72+
for i in range(1, l):
73+
n0, n1 = t[i]
74+
for j in range(m + 1):
75+
for k in range(n + 1):
76+
dp[i][j][k] = dp[i - 1][j][k]
77+
if n0 <= j and n1 <= k:
78+
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - n0][k - n1] + 1)
79+
80+
return dp[-1][-1][-1]
81+
```
5982

83+
空间优化：
84+
85+
```python
86+
class Solution:
87+
def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
88+
dp = [[0] * (n + 1) for _ in range(m + 1)]
89+
t = [(s.count('0'), s.count('1')) for s in strs]
90+
for k in range(len(strs)):
91+
n0, n1 = t[k]
92+
for i in range(m, n0 - 1, -1):
93+
for j in range(n, n1 - 1, -1):
94+
dp[i][j] = max(dp[i][j], dp[i - n0][j - n1] + 1)
95+
return dp[-1][-1]
6096
```
6197

6298
### **Java**
6399

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

66102
```java
103+
class Solution {
104+
public:
105+
int findMaxForm(vector<string>& strs, int m, int n) {
106+
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
107+
for (auto s : strs)
108+
{
109+
vector<int> t = count(s);
110+
for (int i = m; i >= t[0]; --i)
111+
for (int j = n; j >= t[1]; --j)
112+
dp[i][j] = max(dp[i][j], dp[i - t[0]][j - t[1]] + 1);
113+
}
114+
return dp[m][n];
115+
}
116+
117+
vector<int> count(string s) {
118+
int n0 = 0;
119+
for (char c : s)
120+
if (c == '0') ++n0;
121+
return {n0, (int) s.size() - n0};
122+
}
123+
};
124+
```
125+
126+
### **C++**
127+
128+
```cpp
129+
class Solution {
130+
public:
131+
int findMaxForm(vector<string>& strs, int m, int n) {
132+
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
133+
for (int k = 0; k < strs.size(); ++k)
134+
{
135+
vector<int> t = count(strs[k]);
136+
for (int i = m; i >= t[0]; --i)
137+
for (int j = n; j >= t[1]; --j)
138+
dp[i][j] = max(dp[i][j], dp[i - t[0]][j - t[1]] + 1);
139+
}
140+
return dp[m][n];
141+
}
142+
143+
vector<int> count(string s) {
144+
int n0 = 0;
145+
for (char c : s)
146+
if (c == '0') ++n0;
147+
return {n0, (int) s.size() - n0};
148+
}
149+
};
150+
```
67151

152+
### **Go**
153+
154+
```go
155+
func findMaxForm(strs []string, m int, n int) int {
156+
dp := make([][]int, m+1)
157+
for i := 0; i < m+1; i++ {
158+
dp[i] = make([]int, n+1)
159+
}
160+
for _, s := range strs {
161+
t := count(s)
162+
for i := m; i >= t[0]; i-- {
163+
for j := n; j >= t[1]; j-- {
164+
dp[i][j] = max(dp[i][j], dp[i-t[0]][j-t[1]]+1)
165+
}
166+
}
167+
}
168+
return dp[m][n]
169+
}
170+
171+
func count(s string) []int {
172+
n0 := 0
173+
for i := 0; i < len(s); i++ {
174+
if s[i] == '0' {
175+
n0++
176+
}
177+
}
178+
return []int{n0, len(s) - n0}
179+
}
180+
181+
func max(a, b int) int {
182+
if a > b {
183+
return a
184+
}
185+
return b
186+
}
68187
```
69188

70189
### **...**

‎solution/0400-0499/0474.Ones and Zeroes/README_EN.md

+118
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,131 @@ Other valid but smaller subsets include {&quot;0001&quot;, &quot;1&quot;} and {&
4747
### **Python3**
4848

4949
```python
50+
class Solution:
51+
def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
52+
l = len(strs)
53+
dp = [[[0] * (n + 1) for i in range(m + 1)] for j in range(l)]
54+
t = [(s.count('0'), s.count('1')) for s in strs]
55+
n0, n1 = t[0]
56+
for j in range(m + 1):
57+
for k in range(n + 1):
58+
if n0 <= j and n1 <= k:
59+
dp[0][j][k] = 1
60+
61+
for i in range(1, l):
62+
n0, n1 = t[i]
63+
for j in range(m + 1):
64+
for k in range(n + 1):
65+
dp[i][j][k] = dp[i - 1][j][k]
66+
if n0 <= j and n1 <= k:
67+
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - n0][k - n1] + 1)
68+
69+
return dp[-1][-1][-1]
70+
```
5071

72+
```python
73+
class Solution:
74+
def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
75+
dp = [[0] * (n + 1) for _ in range(m + 1)]
76+
t = [(s.count('0'), s.count('1')) for s in strs]
77+
for k in range(len(strs)):
78+
n0, n1 = t[k]
79+
for i in range(m, n0 - 1, -1):
80+
for j in range(n, n1 - 1, -1):
81+
dp[i][j] = max(dp[i][j], dp[i - n0][j - n1] + 1)
82+
return dp[-1][-1]
5183
```
5284

5385
### **Java**
5486

5587
```java
88+
class Solution {
89+
public int findMaxForm(String[] strs, int m, int n) {
90+
int[][] dp = new int[m + 1][n + 1];
91+
for (String s : strs) {
92+
int[] t = count(s);
93+
for (int i = m; i >= t[0]; --i) {
94+
for (int j = n; j >= t[1]; --j) {
95+
dp[i][j] = Math.max(dp[i][j], dp[i - t[0]][j - t[1]] + 1);
96+
}
97+
}
98+
}
99+
return dp[m][n];
100+
}
101+
102+
private int[] count(String s) {
103+
int n0 = 0;
104+
for (char c : s.toCharArray()) {
105+
if (c == '0') {
106+
++n0;
107+
}
108+
}
109+
return new int[]{n0, s.length() - n0};
110+
}
111+
}
112+
```
113+
114+
### **C++**
115+
116+
```cpp
117+
class Solution {
118+
public:
119+
int findMaxForm(vector<string>& strs, int m, int n) {
120+
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
121+
for (auto s : strs)
122+
{
123+
vector<int> t = count(s);
124+
for (int i = m; i >= t[0]; --i)
125+
for (int j = n; j >= t[1]; --j)
126+
dp[i][j] = max(dp[i][j], dp[i - t[0]][j - t[1]] + 1);
127+
}
128+
return dp[m][n];
129+
}
130+
131+
vector<int> count(string s) {
132+
int n0 = 0;
133+
for (char c : s)
134+
if (c == '0') ++n0;
135+
return {n0, (int) s.size() - n0};
136+
}
137+
};
138+
```
56139

140+
### **Go**
141+
142+
```go
143+
func findMaxForm(strs []string, m int, n int) int {
144+
dp := make([][]int, m+1)
145+
for i := 0; i < m+1; i++ {
146+
dp[i] = make([]int, n+1)
147+
}
148+
for _, s := range strs {
149+
t := count(s)
150+
for i := m; i >= t[0]; i-- {
151+
for j := n; j >= t[1]; j-- {
152+
dp[i][j] = max(dp[i][j], dp[i-t[0]][j-t[1]]+1)
153+
}
154+
}
155+
}
156+
return dp[m][n]
157+
}
158+
159+
func count(s string) []int {
160+
n0 := 0
161+
for i := 0; i < len(s); i++ {
162+
if s[i] == '0' {
163+
n0++
164+
}
165+
}
166+
return []int{n0, len(s) - n0}
167+
}
168+
169+
func max(a, b int) int {
170+
if a > b {
171+
return a
172+
}
173+
return b
174+
}
57175
```
58176

59177
### **...**

‎solution/0400-0499/0474.Ones and Zeroes/Solution.cpp

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
class Solution {
2+
public:
3+
int findMaxForm(vector<string>& strs, int m, int n) {
4+
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
5+
for (auto s : strs)
6+
{
7+
vector<int> t = count(s);
8+
for (int i = m; i >= t[0]; --i)
9+
for (int j = n; j >= t[1]; --j)
10+
dp[i][j] = max(dp[i][j], dp[i - t[0]][j - t[1]] + 1);
11+
}
12+
return dp[m][n];
13+
}
14+
15+
vector<int> count(string s) {
16+
int n0 = 0;
17+
for (char c : s)
18+
if (c == '0') ++n0;
19+
return {n0, (int) s.size() - n0};
20+
}
21+
};

‎solution/0400-0499/0474.Ones and Zeroes/Solution.go

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
func findMaxForm(strs []string, m int, n int) int {
2+
dp := make([][]int, m+1)
3+
for i := 0; i < m+1; i++ {
4+
dp[i] = make([]int, n+1)
5+
}
6+
for _, s := range strs {
7+
t := count(s)
8+
for i := m; i >= t[0]; i-- {
9+
for j := n; j >= t[1]; j-- {
10+
dp[i][j] = max(dp[i][j], dp[i-t[0]][j-t[1]]+1)
11+
}
12+
}
13+
}
14+
return dp[m][n]
15+
}
16+
17+
func count(s string) []int {
18+
n0 := 0
19+
for i := 0; i < len(s); i++ {
20+
if s[i] == '0' {
21+
n0++
22+
}
23+
}
24+
return []int{n0, len(s) - n0}
25+
}
26+
27+
func max(a, b int) int {
28+
if a > b {
29+
return a
30+
}
31+
return b
32+
}

‎solution/0400-0499/0474.Ones and Zeroes/Solution.java

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public int findMaxForm(String[] strs, int m, int n) {
3+
int[][] dp = new int[m + 1][n + 1];
4+
for (String s : strs) {
5+
int[] t = count(s);
6+
for (int i = m; i >= t[0]; --i) {
7+
for (int j = n; j >= t[1]; --j) {
8+
dp[i][j] = Math.max(dp[i][j], dp[i - t[0]][j - t[1]] + 1);
9+
}
10+
}
11+
}
12+
return dp[m][n];
13+
}
14+
15+
private int[] count(String s) {
16+
int n0 = 0;
17+
for (char c : s.toCharArray()) {
18+
if (c == '0') {
19+
++n0;
20+
}
21+
}
22+
return new int[]{n0, s.length() - n0};
23+
}
24+
}

‎solution/0400-0499/0474.Ones and Zeroes/Solution.py

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
3+
dp = [[0] * (n + 1) for _ in range(m + 1)]
4+
t = [(s.count('0'), s.count('1')) for s in strs]
5+
for k in range(len(strs)):
6+
n0, n1 = t[k]
7+
for i in range(m, n0 - 1, -1):
8+
for j in range(n, n1 - 1, -1):
9+
dp[i][j] = max(dp[i][j], dp[i - n0][j - n1] + 1)
10+
return dp[-1][-1]

0 commit comments

Comments
 (0)