Maximum Number of Ones - Practice Coding Problems

Maximum Number of Ones - Problem

Maximum Number of Ones is a fascinating optimization problem that challenges you to think about overlapping constraints.

You need to construct a binary matrix (containing only 0s and 1s) with dimensions width × height. However, there's a crucial constraint: every square sub-matrix of size sideLength × sideLength can contain at most maxOnes ones.

Your goal is to determine the maximum possible number of ones that can be placed in the entire matrix while respecting this constraint.

🎯 Key Insight: This isn't just about placing ones randomly - you need to understand how different positions in the matrix contribute to multiple overlapping sub-matrices, and optimize accordingly!

Input & Output

example_1.py — Basic Case

$ Input: width = 3, height = 3, sideLength = 2, maxOnes = 1

› Output: 4

💡 Note: We can place ones at positions forming a checkerboard pattern within the constraints. Each 2×2 sub-matrix contains exactly 1 one, and we maximize the total count.

example_2.py — Larger Matrix

$ Input: width = 2, height = 2, sideLength = 2, maxOnes = 2

› Output: 2

💡 Note: The entire matrix is one 2×2 sub-matrix, so we can place at most 2 ones anywhere in the matrix.

example_3.py — Edge Case

$ Input: width = 1, height = 1, sideLength = 1, maxOnes = 1

› Output: 1

💡 Note: Single cell matrix with single cell sub-matrices. We can place 1 one in the single available position.

Constraints

1 ≤ width ≤ 10³
1 ≤ height ≤ 10³
1 ≤ sideLength ≤ min(width, height)
1 ≤ maxOnes ≤ sideLength²

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Every position (i,j) belongs to equivalence class (i%sideLength, j%sideLength)

Count Frequencies

Count how many matrix positions belong to each equivalence class

Greedy Selection

Sort classes by frequency and select the top maxOnes classes

Calculate Result

Sum the frequencies of selected classes

Key Takeaway

🎯 Key Insight: By recognizing that positions with the same modular coordinates (i%sideLength, j%sideLength) participate in constraints identically, we can group them into equivalence classes and apply a greedy strategy to maximize the total number of ones.

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a greedy frequency-based approach. Key insight: positions (i,j) and (i',j') are equivalent if they have the same modular coordinates (i%sideLength, j%sideLength). All equivalent positions contribute to constraints identically, so we can group them by equivalence class, count frequencies, and greedily select the maxOnes most frequent classes. This achieves O(sideLength²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy by Position Frequency (Optimal)	O(sideLength²)	O(sideLength²)	Group equivalent positions and greedily fill the most frequent ones first
Brute Force (Try All Combinations)	O(2^(w×h) × w × h)	O(w×h)	Generate all possible matrix configurations and check constraints

Greedy by Position Frequency (Optimal) — Algorithm Steps

Group all matrix positions by their equivalence class (i%sideLength, j%sideLength)
Count how many positions belong to each equivalence class
Sort equivalence classes by frequency (most frequent first)
Greedily assign ones to classes until we've used maxOnes ones per constraint

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Patterns

Group positions by (row%sideLength, col%sideLength)

Count Frequencies

Count how many positions belong to each group

Greedy Selection

Select maxOnes most frequent groups

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return *(int*)b - *(int*)a; // Descending order
}

int maximumNumberOfOnes(int width, int height, int sideLength, int maxOnes) {
    // Use array to count frequencies for each (i%sideLength, j%sideLength)
    int freq[sideLength][sideLength];
    for (int i = 0; i < sideLength; i++) {
        for (int j = 0; j < sideLength; j++) {
            freq[i][j] = 0;
        }
    }
    
    // Count frequency of each equivalence class
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            freq[i % sideLength][j % sideLength]++;
        }
    }
    
    // Extract frequencies into array
    int* frequencies = (int*)malloc(sideLength * sideLength * sizeof(int));
    int count = 0;
    for (int i = 0; i < sideLength; i++) {
        for (int j = 0; j < sideLength; j++) {
            if (freq[i][j] > 0) {
                frequencies[count++] = freq[i][j];
            }
        }
    }
    
    // Sort in descending order
    qsort(frequencies, count, sizeof(int), compare);
    
    // Greedily take the most frequent positions
    int result = 0;
    int limit = (maxOnes < count) ? maxOnes : count;
    for (int i = 0; i < limit; i++) {
        result += frequencies[i];
    }
    
    free(frequencies);
    return result;
}

int main() {
    int width, height, sideLength, maxOnes;
    scanf("[%d,%d,%d,%d]", &width, &height, &sideLength, &maxOnes);
    printf("%d\n", maximumNumberOfOnes(width, height, sideLength, maxOnes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(sideLength²)

We process each of the sideLength² equivalence classes once, plus sorting which is also O(sideLength²)

✓ Linear Growth

Space Complexity

O(sideLength²)

Space to store frequency count for each equivalence class

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Greedy by Position Frequency (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler