Table of Contents

# Ones and Zeroes – LeetCode Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions , All you need.

You are given an array of binary strings `strs`

and two integers `m`

and `n`

.

Return *the size of the largest subset of strs such that there are at most *

`m`

`0`

*‘s and*

`n`

`1`

*‘s in the subset*.

A set `x`

is a **subset** of a set `y`

if all elements of `x`

are also elements of `y`

.

**Example 1:**

Input:strs = ["10","0001","111001","1","0"], m = 5, n = 3Output:4Explanation:The largest subset with at most 5 0's and 3 1's is {"10", "0001", "1", "0"}, so the answer is 4. Other valid but smaller subsets include {"0001", "1"} and {"10", "1", "0"}. {"111001"} is an invalid subset because it contains 4 1's, greater than the maximum of 3.

**Example 2:**

Input:strs = ["10","0","1"], m = 1, n = 1Output:2Explanation:The largest subset is {"0", "1"}, so the answer is 2.

**Constraints:**

`1 <= strs.length <= 600`

`1 <= strs[i].length <= 100`

`strs[i]`

consists only of digits`'0'`

and`'1'`

.`1 <= m, n <= 100`

# C++ Ones and Zeroes LeetCode Solution

```
``````
int findMaxForm(vector<string>& strs, int m, int n) {
vector<vector<int>> memo(m+1, vector<int>(n+1, 0));
int numZeroes, numOnes;
for (auto &s : strs) {
numZeroes = numOnes = 0;
// count number of zeroes and ones in current string
for (auto c : s) {
if (c == '0')
numZeroes++;
else if (c == '1')
numOnes++;
}
// memo[i][j] = the max number of strings that can be formed with i 0's and j 1's
// from the first few strings up to the current string s
// Catch: have to go from bottom right to top left
// Why? If a cell in the memo is updated(because s is selected),
// we should be adding 1 to memo[i][j] from the previous iteration (when we were not considering s)
// If we go from top left to bottom right, we would be using results from this iteration => overcounting
for (int i = m; i >= numZeroes; i--) {
for (int j = n; j >= numOnes; j--) {
memo[i][j] = max(memo[i][j], memo[i - numZeroes][j - numOnes] + 1);
}
}
}
return memo[m][n];
}
```

# Java Ones and Zeroes LeetCode Solution

```
``````
public int findMaxForm(String[] strs, int m, int n) {
int[][] dp = new int[m+1][n+1];
for (String s : strs) {
int[] count = count(s);
for (int i=m;i>=count[0];i--)
for (int j=n;j>=count[1];j--)
dp[i][j] = Math.max(1 + dp[i-count[0]][j-count[1]], dp[i][j]);
}
return dp[m][n];
}
public int[] count(String str) {
int[] res = new int[2];
for (int i=0;i<str.length();i++)
res[str.charAt(i) - '0']++;
return res;
}
```

# Python 3 Ones and Zeroes LeetCode Solution

```
``````
class Solution:
def findMaxForm(self, S: List[str], M: int, N: int) -> int:
dp = [[0 for _ in range(N+1)] for _ in range(M+1)]
for str in S:
zeros = str.count("0")
ones = len(str) - zeros
for i in range(M, zeros - 1, -1):
for j in range(N, ones - 1, -1):
dp[i][j] = max(dp[i][j], dp[i-zeros][j-ones] + 1)
return dp[M][N]
```

Array-1180

String-562

Hash Table-412

Dynamic Programming-390

Math-368

Sorting-264

Greedy-257

Depth-First Search-256

Database-215

Breadth-First Search-200

Tree-195

Binary Search-191

Matrix-176

Binary Tree-160

Two Pointers-151

Bit Manipulation-140

Stack-133

Heap (Priority Queue)-117

Design-116

Graph-108

Simulation-103

Prefix Sum-96

Backtracking-92

Counting-86

Sliding Window-73

Linked List-69

Union Find-66

Ordered Set-48

Monotonic Stack-47

Recursion-43

Trie-41

Binary Search Tree-40

Divide and Conquer-40

Enumeration-39

Bitmask-37

Queue-33

Memoization-32

Topological Sort-31

Geometry-30

Segment Tree-27

Game Theory-24

Hash Function-24

Binary Indexed Tree-21

Interactive-18

Data Stream-17

String Matching-17

Rolling Hash-17

Shortest Path-16

Number Theory-16

Combinatorics-15

Randomized-12

Monotonic Queue-9

Iterator-9

Merge Sort-9

Concurrency-9

Doubly-Linked List-8

Brainteaser-8

Probability and Statistics-7

Quickselect-7

Bucket Sort-6

Suffix Array-6

Minimum Spanning Tree-5

Counting Sort-5

Shell-4

Line Sweep-4

Reservoir Sampling-4

Eulerian Circuit-3

Radix Sort-3

Strongly Connected Componen-t2

Rejection Sampling-2

Biconnected Component-1