Ones and Zeroes

Ones and Zeroes - Problem

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 zeros ('0's) and n ones ('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.

Input & Output

Example 1 — Basic Case

$ Input: strs = ["10","0001","111001","1","0"], m = 5, n = 3

› Output: 4

💡 Note: We can select at most 4 strings: "10" (1 zero, 1 one), "0001" (3 zeros, 1 one), "1" (0 zeros, 1 one), "0" (1 zero, 0 ones). Total: 5 zeros, 3 ones, which fits exactly within our limits.

Example 2 — Tight Constraints

$ Input: strs = ["10","0","1"], m = 1, n = 1

› Output: 2

💡 Note: With only 1 zero and 1 one allowed, we can take either "10" (1 zero, 1 one) for count=1, OR "0" + "1" (1 zero, 1 one total) for count=2. The second option is better.

Example 3 — Edge Case

$ Input: strs = ["111","1000"], m = 3, n = 1

› Output: 1

💡 Note: "111" has 3 ones but we only have budget for 1 one. "1000" has 3 zeros and 1 one, fits our constraints. Answer is 1.

Constraints

1 ≤ strs.length ≤ 600
1 ≤ strs[i].length ≤ 100
strs[i] consists only of digits '0' and '1'
1 ≤ m, n ≤ 100

Visualization

Tap to expand

Asked in

G Google 28 f Facebook 15 M Microsoft 12 a Amazon 8

This is a 3D knapsack problem where each string has two costs (zeros and ones) and we want to maximize the count of items taken. The key insight is to use 2D dynamic programming where dp[i][j] represents the maximum number of strings achievable with at most i zeros and j ones. Best approach is 2D DP with Time: O(k×m×n), Space: O(m×n).

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(k × m × n + L) Space: O(m × n)

Use bottom-up dynamic programming with a 2D table where dp[i][j] represents the maximum number of strings we can select using at most i zeros and j ones. Process strings one by one, updating the table.

Recursion with Memoization

⏱️ Time: O(k × m × n) Space: O(k × m × n)

Use top-down dynamic programming with memoization. Store results of subproblems defined by (current index, remaining zeros, remaining ones) to avoid recalculating the same state multiple times.

Recursive Brute Force

⏱️ Time: O(2^k × L) Space: O(k)

Generate all possible subsets of strings and check which ones satisfy the m zeros and n ones constraint. Return the size of the largest valid subset.

2D Dynamic Programming — Algorithm Steps

Create 2D DP table dp[m+1][n+1] initialized to 0
For each string, count its zeros and ones
Update DP table from bottom-right to avoid using updated values
Return dp[m][n] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create (m+1)×(n+1) table filled with zeros

Process Strings

For each string, update table backwards

Final Answer

dp[m][n] contains maximum subset size

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void countZerosOnes(char* s, int* zeros, int* ones) {
    *zeros = 0;
    *ones = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] == '0') (*zeros)++;
        else (*ones)++;
    }
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int findMaxForm(char** strs, int strsSize, int m, int n) {
    int** dp = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int k = 0; k < strsSize; k++) {
        int zeros, ones;
        countZerosOnes(strs[k], &zeros, &ones);
        
        for (int i = m; i >= zeros; i--) {
            for (int j = n; j >= ones; j--) {
                dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1);
            }
        }
    }
    
    int result = dp[m][n];
    
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[10000];
    char** strs = NULL;
    int strsSize = 0;
    int m, n;
    
    if (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = 0;
        
        char* start = strchr(line, '[');
        char* end = strrchr(line, ']');
        if (start && end) {
            start++;
            *end = '\0';
            
            char* temp = strdup(start);
            char* token = strtok(temp, ",");
            while (token) {
                strsSize++;
                token = strtok(NULL, ",");
            }
            free(temp);
            
            strs = (char**)malloc(strsSize * sizeof(char*));
            
            int idx = 0;
            token = strtok(start, ",");
            while (token) {
                while (*token == ' ' || *token == '"') token++;
                char* endQuote = strchr(token, '"');
                if (endQuote) *endQuote = '\0';
                
                strs[idx] = (char*)malloc((strlen(token) + 1) * sizeof(char));
                strcpy(strs[idx], token);
                idx++;
                
                token = strtok(NULL, ",");
            }
        }
    }
    
    if (fgets(line, sizeof(line), stdin)) {
        m = atoi(line);
    }
    
    if (fgets(line, sizeof(line), stdin)) {
        n = atoi(line);
    }
    
    int result = findMaxForm(strs, strsSize, m, n);
    printf("%d\n", result);
    
    for (int i = 0; i < strsSize; i++) {
        free(strs[i]);
    }
    free(strs);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × m × n + L)

k strings × m zeros × n ones DP updates, plus L total characters to count zeros/ones

✓ Linear Growth

Space Complexity

O(m × n)

2D DP table of size (m+1) × (n+1)

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~25 min Avg. Time

3.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler