Maximum Number of Ones

Maximum Number of Ones - Problem

Consider a matrix M with dimensions width × height, where every cell has value 0 or 1. There is a constraint that any square sub-matrix of M of size sideLength × sideLength can have at most maxOnes ones.

Goal: Return the maximum possible number of ones that the matrix M can have while satisfying this constraint.

Key insight: This is a mathematical optimization problem where we need to distribute ones optimally across the matrix such that no square sub-matrix violates the constraint.

Input & Output

Example 1 — Basic Square

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

› Output: 4

💡 Note: In a 3×3 matrix, we need every 2×2 sub-matrix to have ≤1 ones. Optimal placement is checkerboard pattern in corners: positions (0,0), (0,2), (2,0), (2,2) can all be 1 without violating constraints.

Example 2 — Rectangular Matrix

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

› Output: 2

💡 Note: In a 2×3 matrix with 2×2 constraint, we have two 2×2 sub-matrices that overlap. We can place at most 2 ones total while keeping each sub-matrix ≤1.

Example 3 — No Ones Allowed

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

› Output: 0

💡 Note: When maxOnes = 0, no sub-matrix can contain any ones, so the entire matrix must be all zeros.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 f Facebook 22 a Amazon 18

The key insight is recognizing that this is a mathematical optimization problem rather than a simulation. Instead of trying all matrix configurations, we analyze how positions in a repeating pattern contribute to multiple overlapping sub-matrix constraints. The optimal approach uses greedy pattern recognition to place ones in positions that appear in the fewest sub-matrices. Time: O(sideLength²), Space: O(sideLength²)

Common Approaches

✓ Brute Force - Try All Configurations

⏱️ Time: O(2^(width×height) × (width-sideLength+1) × (height-sideLength+1)) Space: O(width × height)

Try every possible assignment of 0s and 1s to the matrix cells, then verify each configuration satisfies the sub-matrix constraint. This approach is exhaustive but extremely slow.

Mathematical Pattern Recognition

⏱️ Time: O(sideLength²) Space: O(sideLength²)

Instead of brute force, we recognize that the optimal placement follows a repeating pattern. We divide the matrix into blocks based on sideLength and distribute ones optimally within each pattern.

Brute Force - Try All Configurations — Algorithm Steps

Generate all 2^(width×height) possible matrices
For each matrix, check all sub-matrices of size sideLength×sideLength
Count ones in valid configurations and return maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^(w×h) possible 0/1 matrices

Validate

Check each sub-matrix constraint

Count

Track maximum valid ones count

Code -

solution.c — C

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

int solution(int width, int height, int sideLength, int maxOnes) {
    if (width * height > 20) return 0;
    
    int maxOnesCount = 0;
    
    for (int config = 0; config < (1 << (width * height)); config++) {
        int matrix[20][20] = {0};
        int onesCount = 0;
        
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                int pos = i * width + j;
                if (config & (1 << pos)) {
                    matrix[i][j] = 1;
                    onesCount++;
                }
            }
        }
        
        int valid = 1;
        for (int i = 0; i <= height - sideLength && valid; i++) {
            for (int j = 0; j <= width - sideLength && valid; j++) {
                int subOnes = 0;
                for (int x = i; x < i + sideLength; x++) {
                    for (int y = j; y < j + sideLength; y++) {
                        subOnes += matrix[x][y];
                    }
                }
                if (subOnes > maxOnes) {
                    valid = 0;
                }
            }
        }
        
        if (valid && onesCount > maxOnesCount) {
            maxOnesCount = onesCount;
        }
    }
    
    return maxOnesCount;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^(width×height) × (width-sideLength+1) × (height-sideLength+1))

2^(w×h) configurations, each requiring O(w×h) sub-matrix checks

✓ Linear Growth

Space Complexity

O(width × height)

Store the matrix configuration being tested

✓ Linear Space

28.5K Views

Medium Frequency

~45 min Avg. Time

892 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

Brute Force - Try All Configurations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler