Maximum Matrix Sum - Practice Coding Problems

Maximum Matrix Sum - Problem

You are given an n × n integer matrix. Your mission is to maximize the sum of all elements in the matrix using a special operation.

The Operation: Choose any two adjacent elements in the matrix and multiply both by -1. Two elements are adjacent if they share a border (horizontally or vertically connected).

You can perform this operation any number of times, including zero times. Your goal is to find the maximum possible sum of all matrix elements after applying operations optimally.

Example: In matrix [[-1, 0, 1], [0, -1, 0], [1, 0, -1]], you can flip adjacent negative values to make them positive, maximizing the total sum.

Input & Output

example_1.py — Basic 2x2 Matrix

$ Input: matrix = [[1,-1],[-1,1]]

› Output: 4

💡 Note: We can flip the pair (-1,-1) to make them both positive, or flip (1,-1) and (-1,1) to achieve sum of 4. All elements become positive: [[1,1],[1,1]]

example_2.py — 3x3 with Odd Negatives

$ Input: matrix = [[1,2,3],[-1,-2,-3],[1,2,3]]

› Output: 16

💡 Note: We have 3 negative values (odd count). We can pair -1 and -2, but -3 must remain negative since we have odd count. Sum = 1+2+3+1+2+3+1+2-3 = 12. But optimally, we keep the smallest absolute value (-1) negative: 16.

example_3.py — All Positive

$ Input: matrix = [[2,3],[5,4]]

› Output: 14

💡 Note: All elements are already positive, so no operations needed. Maximum sum is 2+3+5+4 = 14.

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 250
-10⁵ ≤ matrix[i][j] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Analyze the Board

Count how many black squares (negatives) you have and identify the lightest gray square (minimum absolute value)

Pair Up Negatives

Each pair of black squares can be converted to white squares through adjacent flips

Handle the Remainder

If you have an odd number of black squares, one must remain black - choose the one that hurts your score the least

Key Takeaway

🎯 Key Insight: Since each operation flips exactly two adjacent elements, we can always pair up negatives to make them positive. If we have an odd number of negatives, exactly one must remain negative - choose the one with smallest absolute value to minimize the loss.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy approach with the key insight that adjacent flips can eliminate pairs of negative values. Count negatives and sum absolute values - if negative count is odd, subtract twice the minimum absolute value since one element must remain negative.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n²)	O(1)	Sum absolute values and handle odd negative count optimally
Brute Force Simulation	O(4^(n²))	O(4^(n²))	Try all possible sequences of adjacent element flips

Greedy Approach (Optimal) — Algorithm Steps

Calculate the sum of absolute values of all elements
Count the number of negative elements in the matrix
Find the element with the smallest absolute value
If negative count is even, return the sum of absolute values
If negative count is odd, subtract twice the smallest absolute value

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Elements

Count negatives and find minimum absolute value

Pair Negatives

Each pair of negatives can be made positive

Handle Odd Case

If odd number of negatives, smallest absolute value stays negative

Calculate Result

Sum of absolute values minus adjustment for odd case

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

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

long long maxMatrixSum(int** matrix, int n) {
    long long totalSum = 0;
    int negativeCount = 0;
    int minAbsValue = INT_MAX;
    
    // Single pass to gather all needed information
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int value = matrix[i][j];
            int absValue = abs_val(value);
            
            totalSum += absValue;
            minAbsValue = min(minAbsValue, absValue);
            
            if (value < 0) {
                negativeCount++;
            }
        }
    }
    
    // If we have even number of negatives, we can make all positive
    // If we have odd number of negatives, one must remain negative
    // Choose the one with smallest absolute value to remain negative
    if (negativeCount % 2 == 1) {
        totalSum -= 2LL * minAbsValue;
    }
    
    return totalSum;
}

int main() {
    // Parse matrix input
    int** matrix;
    int n;
    printf("%lld\n", maxMatrixSum(matrix, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through the matrix to compute sum, count negatives, and find minimum absolute value

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sum, count, and minimum value

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler