chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2026-01-11-85-Maximal-Rectangle/explanation.md

@@ -0,0 +1,34 @@
+# Maximal Rectangle (Hard)
+
+**Problem ID:** 85  
+**Date:** 2026-01-11  
+**Link:** https://leetcode.com/problems/maximal-rectangle/
+
+## Approach
+
+To solve the "Maximal Rectangle" problem, we can leverage a dynamic programming approach combined with the concept of the largest rectangle in a histogram. The main idea is to treat each row of the binary matrix as the base of a histogram where the height of each column represents the number of consecutive '1's up to that row.
+
+### Approach:
+
+1. **Transform the Matrix**: 
+   - Create an auxiliary array `heights` of size equal to the number of columns in the matrix. This array will store the heights of '1's for each column as we iterate through each row of the matrix.
+   - For each cell in the matrix, if the cell contains '1', increment the corresponding height in `heights` by 1; if it contains '0', reset that height to 0.
+
+2. **Calculate Maximum Rectangle for Each Row**:
+   - For each row in the matrix, after updating the `heights` array, treat `heights` as a histogram and compute the largest rectangle that can be formed using the heights. This can be efficiently done using a stack-based approach which allows us to find the largest rectangle area in O(cols) time.
+
+3. **Iterate Through Rows**:
+   - Repeat the process for each row in the matrix, updating the `heights` and calculating the maximum rectangle area for each updated histogram.
+
+4. **Track the Maximum Area**:
+   - Maintain a variable to track the maximum area encountered during these calculations.
+
+### Data Structures:
+- An array `heights` to store the heights of '1's in each column.
+- A stack to efficiently compute the largest rectangle area in the histogram.
+
+### Complexity:
+- **Time Complexity**: O(rows * cols), where `rows` is the number of rows and `cols` is the number of columns in the matrix. This is because we process each cell once and compute the histogram area in linear time for each row.
+- **Space Complexity**: O(cols) for the `heights` array and O(cols) for the stack, leading to an overall space complexity of O(cols).
+
+This approach effectively reduces the problem of finding the maximal rectangle in a binary matrix to a series of histogram problems, allowing us to solve it efficiently.

Hard/2026-01-11-85-Maximal-Rectangle/solution.java

@@ -0,0 +1,51 @@
+class Solution {
+    public int maximalRectangle(char[][] matrix) {
+        if (matrix.length == 0) return 0;
+        int maxArea = 0;
+        int[] heights = new int[matrix[0].length];
+        
+        for (int i = 0; i < matrix.length; i++) {
+            for (int j = 0; j < matrix[0].length; j++) {
+                if (matrix[i][j] == '1') {
+                    heights[j] += 1;
+                } else {
+                    heights[j] = 0;
+                }
+            }
+            maxArea = Math.max(maxArea, largestRectangleArea(heights));
+        }
+        
+        return maxArea;
+    }
+    
+    private int largestRectangleArea(int[] heights) {
+        int maxArea = 0;
+        int[] left = new int[heights.length];
+        int[] right = new int[heights.length];
+        Stack<Integer> stack = new Stack<>();
+        
+        for (int i = 0; i < heights.length; i++) {
+            while (!stack.isEmpty() && heights[stack.peek()] >= heights[i]) {
+                stack.pop();
+            }
+            left[i] = stack.isEmpty() ? -1 : stack.peek();
+            stack.push(i);
+        }
+        
+        stack.clear();
+        
+        for (int i = heights.length - 1; i >= 0; i--) {
+            while (!stack.isEmpty() && heights[stack.peek()] >= heights[i]) {
+                stack.pop();
+            }
+            right[i] = stack.isEmpty() ? heights.length : stack.peek();
+            stack.push(i);
+        }
+        
+        for (int i = 0; i < heights.length; i++) {
+            maxArea = Math.max(maxArea, (right[i] - left[i] - 1) * heights[i]);
+        }
+        
+        return maxArea;
+    }
+}

Hard/2026-01-11-85-Maximal-Rectangle/solution.js

@@ -0,0 +1,34 @@
+var maximalRectangle = function(matrix) {
+    if (matrix.length === 0) return 0;
+    
+    const rows = matrix.length;
+    const cols = matrix[0].length;
+    const heights = Array(cols).fill(0);
+    let maxArea = 0;
+
+    for (let i = 0; i < rows; i++) {
+        for (let j = 0; j < cols; j++) {
+            heights[j] = matrix[i][j] === '1' ? heights[j] + 1 : 0;
+        }
+        maxArea = Math.max(maxArea, largestRectangleArea(heights));
+    }
+
+    return maxArea;
+};
+
+function largestRectangleArea(heights) {
+    const stack = [];
+    let maxArea = 0;
+    heights.push(0); // Add a sentinel value
+
+    for (let i = 0; i < heights.length; i++) {
+        while (stack.length && heights[stack[stack.length - 1]] > heights[i]) {
+            const h = heights[stack.pop()];
+            const w = stack.length ? i - stack[stack.length - 1] - 1 : i;
+            maxArea = Math.max(maxArea, h * w);
+        }
+        stack.push(i);
+    }
+
+    return maxArea;
+}

Hard/2026-01-11-85-Maximal-Rectangle/solution.py

@@ -0,0 +1,29 @@
+class Solution:
+    def maximalRectangle(self, matrix: List[List[str]]) -> int:
+        if not matrix or not matrix[0]:
+            return 0
+        
+        max_area = 0
+        heights = [0] * len(matrix[0])
+        
+        for row in matrix:
+            for i in range(len(row)):
+                heights[i] = heights[i] + 1 if row[i] == '1' else 0
+            
+            max_area = max(max_area, self.largestRectangleArea(heights))
+        
+        return max_area
+    
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        heights.append(0)
+        stack = []
+        max_area = 0
+        
+        for i in range(len(heights)):
+            while stack and heights[stack[-1]] > heights[i]:
+                h = heights[stack.pop()]
+                w = i if not stack else i - stack[-1] - 1
+                max_area = max(max_area, h * w)
+            stack.append(i)
+        
+        return max_area

README.md

@@ -330,3 +330,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-06 — [Maximum Level Sum of a Binary Tree](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/) (Medium) → `Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree`
 - 2026-01-07 — [Maximum Product of Splitted Binary Tree](https://leetcode.com/problems/maximum-product-of-splitted-binary-tree/) (Medium) → `Medium/2026-01-07-1339-Maximum-Product-of-Splitted-Binary-Tree`
 - 2026-01-08 — [Max Dot Product of Two Subsequences](https://leetcode.com/problems/max-dot-product-of-two-subsequences/) (Hard) → `Hard/2026-01-08-1458-Max-Dot-Product-of-Two-Subsequences`
+- 2026-01-11 — [Maximal Rectangle](https://leetcode.com/problems/maximal-rectangle/) (Hard) → `Hard/2026-01-11-85-Maximal-Rectangle`