Largest Magic Square - Practice Coding Problems

Largest Magic Square - Problem

A magic square is like a perfect puzzle where all the numbers align harmoniously! 🎯

Given a k × k grid filled with integers, it becomes a magic square when:

Every row sum equals the same value
Every column sum equals the same value
Both diagonal sums equal the same value

Note: The integers don't need to be distinct, and every 1×1 grid is trivially a magic square.

Your Mission: Given an m × n integer grid, find the size (side length k) of the largest magic square that can be found within this grid.

Example: In a 4×4 grid, you might find a 3×3 magic square where all rows, columns, and diagonals sum to 15.

Input & Output

example_1.py — Basic Magic Square

$ Input: grid = [[7,1,4,5,6],[2,5,1,6,4],[1,5,4,3,2],[1,2,7,3,4]]

› Output: 2

💡 Note: The largest magic square is 2×2. For example, the subgrid [[7,1],[2,5]] has sums: rows=[8,7], cols=[9,6], diags=[12,3] - not magic. But [[1,6],[3,2]] has sums: rows=[7,5], cols=[4,8], diags=[3,8] - not magic either. However, [[5,1],[5,4]] has all sums equal to 6: rows=[6,9], cols=[10,5], diags=[9,6] - still not magic. The actual 2×2 magic square would be found through systematic checking.

example_2.py — Single Element

$ Input: grid = [[5]]

› Output: 1

💡 Note: A 1×1 grid is trivially a magic square since there's only one element, so all 'sums' are equal to that element's value.

example_3.py — Large Grid

$ Input: grid = [[3,2,9,2,7],[6,1,8,4,2],[7,5,3,2,7],[2,9,4,9,6],[4,3,8,2,5]]

› Output: 1

💡 Note: In this 5×5 grid, no magic square larger than 1×1 can be found. Every 2×2, 3×3, 4×4, and 5×5 subgrid fails the magic square test where all rows, columns, and diagonals must have equal sums.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
1 ≤ grid[i][j] ≤ 10⁶
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Scan Grid Positions

Try every possible top-left corner position for potential magic squares

Test Square Sizes

For each position, test increasing square sizes from 1×1 to maximum possible

Verify Magic Property

Check if all rows, columns, and diagonals sum to the same value

Track Maximum

Keep track of the largest valid magic square size found

Optimize with Prefix Sums

Use precomputed sums to avoid recalculating the same regions repeatedly

Key Takeaway

🎯 Key Insight: Use prefix sums to transform O(k²) sum calculations into O(1) lookups, then binary search on the answer since magic square existence has monotonic property.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses binary search on the answer combined with prefix sums for efficient verification. Since magic square sizes have a natural ordering (if size k doesn't work, size k+1 won't either), we can binary search from 1 to min(m,n). For each candidate size, we use 2D prefix sums to verify row and column sums in O(1) time, only computing diagonal sums manually in O(k) time.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(mnmin(m,n)*log(min(m,n)))	O(m*n)	Binary search on the size k, using prefix sums for fast verification
Brute Force (Check Every Square)	O(m²n²k³)	O(1)	Try every possible square position and size, calculating all sums directly

Binary Search on Answer — Algorithm Steps

Build prefix sum arrays for fast range sum queries
Binary search on the possible sizes (1 to min(m,n))
For each size k, check all possible positions
Use prefix sums to calculate row/column sums in O(1)
Calculate diagonal sums by iterating through elements
If any valid magic square found, search for larger size
Otherwise, search for smaller size

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sums

Create 2D prefix sum array for O(1) range queries

Binary Search

Search for maximum k where magic square exists

Fast Verification

Use prefix sums to check rows/columns in O(1)

Check Diagonals

Manually verify diagonal sums for each candidate

Update Bounds

Adjust search range based on result

Code -

solution.c — C

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

int min(int a, int b) { return a < b ? a : b; }

int getSum(int** prefix, int r1, int c1, int r2, int c2) {
    return prefix[r2 + 1][c2 + 1] - prefix[r1][c2 + 1] - prefix[r2 + 1][c1] + prefix[r1][c1];
}

int canMakeMagicSquare(int** grid, int** prefix, int m, int n, int k) {
    if (k == 1) return 1;
    
    for (int i = 0; i <= m - k; i++) {
        for (int j = 0; j <= n - k; j++) {
            // Get target sum from first row
            int target = getSum(prefix, i, j, i, j + k - 1);
            
            // Check all rows
            int valid = 1;
            for (int row = 0; row < k && valid; row++) {
                if (getSum(prefix, i + row, j, i + row, j + k - 1) != target) {
                    valid = 0;
                }
            }
            
            if (!valid) continue;
            
            // Check all columns
            for (int col = 0; col < k && valid; col++) {
                if (getSum(prefix, i, j + col, i + k - 1, j + col) != target) {
                    valid = 0;
                }
            }
            
            if (!valid) continue;
            
            // Check diagonals
            int diag1 = 0, diag2 = 0;
            for (int d = 0; d < k; d++) {
                diag1 += grid[i + d][j + d];
                diag2 += grid[i + d][j + k - 1 - d];
            }
            
            if (diag1 == target && diag2 == target) {
                return 1;
            }
        }
    }
    
    return 0;
}

int largestMagicSquare(int** grid, int m, int n) {
    // Build prefix sum arrays
    int** prefix = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        prefix[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            prefix[i + 1][j + 1] = grid[i][j] + prefix[i][j + 1] + prefix[i + 1][j] - prefix[i][j];
        }
    }
    
    // Binary search on the answer
    int left = 1, right = min(m, n);
    int result = 1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canMakeMagicSquare(grid, prefix, m, n, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(prefix[i]);
    }
    free(prefix);
    
    return result;
}

int main() {
    // Input parsing would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*min(m,n)*log(min(m,n)))

O(log(min(m,n))) for binary search × O(m*n) positions × O(min(m,n)) for diagonal verification

⚡ Linearithmic

Space Complexity

O(m*n)

Space for prefix sum arrays to enable O(1) range sum queries

⚡ Linearithmic Space

32.2K Views

Medium-High 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler