chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-05-1975-Maximum-Matrix-Sum/explanation.md

@@ -0,0 +1,42 @@
+# Maximum Matrix Sum (Medium)
+
+**Problem ID:** 1975  
+**Date:** 2026-01-05  
+**Link:** https://leetcode.com/problems/maximum-matrix-sum/
+
+## Approach
+
+To solve the problem of maximizing the sum of an n x n integer matrix after performing the specified operation (multiplying two adjacent elements by -1), we can follow these steps:
+
+### Problem Understanding
+The key operation allows us to change the sign of two adjacent elements in the matrix. This means that we can effectively flip the sign of pairs of elements, which can help us increase the overall sum of the matrix. The goal is to determine the maximum possible sum after performing any number of such operations.
+
+### Approach
+1. **Calculate the Initial Sum**: Start by calculating the initial sum of all elements in the matrix. This will serve as a baseline for our calculations.
+
+2. **Identify Negative Elements**: Count the number of negative elements in the matrix. The presence of negative elements is crucial since they will contribute negatively to the overall sum.
+
+3. **Determine the Minimum Absolute Value**: Find the element with the smallest absolute value in the matrix. This value will be important for deciding how to handle the sign flips.
+
+4. **Evaluate the Effect of Flips**:
+   - If the count of negative elements is even, we can flip pairs of negatives to make them positive, maximizing the sum without any remaining negatives.
+   - If the count of negative elements is odd, one negative will remain after all possible flips. In this case, we can flip the smallest absolute value element (which could be either negative or positive) to minimize the negative impact on the sum.
+
+5. **Calculate the Maximum Sum**:
+   - If there are an even number of negatives, the maximum sum is simply the absolute value of the initial sum.
+   - If there are an odd number of negatives, the maximum sum can be calculated as:
+     \[
+     \text{max\_sum} = \text{initial\_sum} + 2 \times \text{smallest\_absolute\_value}
+     \]
+   This accounts for flipping the smallest absolute value element to mitigate the effect of the remaining negative.
+
+### Data Structures
+- A simple 2D array (matrix) to store the input values.
+- Variables to keep track of the initial sum, count of negative elements, and the smallest absolute value.
+
+### Complexity
+- **Time Complexity**: O(n^2) due to the need to iterate through all elements of the n x n matrix to calculate the initial sum, count negatives, and find the minimum absolute value.
+- **Space Complexity**: O(1) since we are using a constant amount of extra space regardless of the input size.
+
+### Conclusion
+By leveraging the properties of the operations allowed and focusing on the count of negative numbers and the smallest absolute value, we can efficiently compute the maximum possible sum of the matrix after performing the operations. This approach ensures that we handle both even and odd counts of negative elements appropriately to achieve the desired result.

Medium/2026-01-05-1975-Maximum-Matrix-Sum/solution.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int maxMatrixSum(int[][] matrix) {
+        int n = matrix.length;
+        long totalSum = 0;
+        int minAbsValue = Integer.MAX_VALUE;
+        int negativeCount = 0;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                int value = matrix[i][j];
+                totalSum += Math.abs(value);
+                if (value < 0) {
+                    negativeCount++;
+                }
+                minAbsValue = Math.min(minAbsValue, Math.abs(value));
+            }
+        }
+
+        if (negativeCount % 2 == 0) {
+            return (int) totalSum;
+        } else {
+            return (int) (totalSum - 2 * minAbsValue);
+        }
+    }
+}

Medium/2026-01-05-1975-Maximum-Matrix-Sum/solution.js

@@ -0,0 +1,21 @@
+var maxMatrixSum = function(matrix) {
+    let totalSum = 0;
+    let minAbsValue = Infinity;
+    let negativeCount = 0;
+
+    for (let row of matrix) {
+        for (let num of row) {
+            if (num < 0) {
+                negativeCount++;
+            }
+            totalSum += Math.abs(num);
+            minAbsValue = Math.min(minAbsValue, Math.abs(num));
+        }
+    }
+
+    if (negativeCount % 2 === 0) {
+        return totalSum;
+    } else {
+        return totalSum - 2 * minAbsValue;
+    }
+};

Medium/2026-01-05-1975-Maximum-Matrix-Sum/solution.py

@@ -0,0 +1,17 @@
+class Solution:
+    def maxMatrixSum(self, matrix: List[List[int]]) -> int:
+        total_sum = 0
+        min_abs_value = float('inf')
+        negative_count = 0
+        
+        for row in matrix:
+            for value in row:
+                if value < 0:
+                    negative_count += 1
+                total_sum += abs(value)
+                min_abs_value = min(min_abs_value, abs(value))
+        
+        if negative_count % 2 == 0:
+            return total_sum
+        else:
+            return total_sum - 2 * min_abs_value

README.md

@@ -326,3 +326,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-02 — [N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/) (Easy) → `Easy/2026-01-02-961-N-Repeated-Element-in-Size-2N-Array`
 - 2026-01-03 — [Number of Ways to Paint N × 3 Grid](https://leetcode.com/problems/number-of-ways-to-paint-n-3-grid/) (Hard) → `Hard/2026-01-03-1411-Number-of-Ways-to-Paint-N-3-Grid`
 - 2026-01-04 — [Four Divisors](https://leetcode.com/problems/four-divisors/) (Medium) → `Medium/2026-01-04-1390-Four-Divisors`
+- 2026-01-05 — [Maximum Matrix Sum](https://leetcode.com/problems/maximum-matrix-sum/) (Medium) → `Medium/2026-01-05-1975-Maximum-Matrix-Sum`