chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-29-756-Pyramid-Transition-Matrix/explanation.md

@@ -0,0 +1,34 @@
+# Pyramid Transition Matrix (Medium)
+
+**Problem ID:** 756  
+**Date:** 2025-12-29  
+**Link:** https://leetcode.com/problems/pyramid-transition-matrix/
+
+## Approach
+
+To solve the Pyramid Transition Matrix problem, we can use a depth-first search (DFS) approach combined with memoization to efficiently explore the possible configurations of the pyramid.
+
+### Approach:
+
+1. **Understanding the Structure**:
+   - The pyramid is constructed from a base row of blocks, where each block can be represented by a character. Each pair of adjacent blocks in the current row can form a new block in the row above it based on the allowed triangular patterns.
+
+2. **Data Structures**:
+   - Use a set to store the allowed patterns for quick lookup.
+   - Utilize a recursive function to explore the possible configurations of the pyramid. This function will take the current row of blocks as input and attempt to build the row above it.
+
+3. **Recursive Function**:
+   - The recursive function will check pairs of adjacent blocks in the current row. For each pair, it will look for all valid top blocks that can be formed using the allowed patterns.
+   - For each valid top block found, the function will recursively call itself with the new row (which includes the newly formed top block) until reaching the top of the pyramid (when the row has only one block).
+
+4. **Base Case**:
+   - The recursion stops when the row length is 1, indicating that the pyramid has been successfully built.
+
+5. **Memoization**:
+   - To optimize the function, store results of previously computed states (current row) to avoid redundant calculations. This can be done using a dictionary where keys are the current row strings and values indicate whether that configuration can lead to a valid pyramid.
+
+6. **Complexity**:
+   - The time complexity is primarily influenced by the number of states explored and the number of allowed patterns. Given the constraints, the worst-case scenario involves exploring multiple configurations, but memoization drastically reduces the number of unique states. The space complexity is also O(n) due to the storage of the memoization dictionary.
+
+### Summary:
+By leveraging DFS and memoization, we can efficiently explore all possible configurations of the pyramid, checking against the allowed patterns to determine if a valid pyramid can be formed from the given base row. This approach ensures that we systematically build the pyramid while avoiding unnecessary recalculations, making it feasible within the problem’s constraints.

Medium/2025-12-29-756-Pyramid-Transition-Matrix/solution.java

@@ -0,0 +1,40 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    private Map<String, HashSet<Character>> allowedMap;
+
+    public boolean pyramidTransition(String bottom, List<String> allowed) {
+        allowedMap = new HashMap<>();
+        for (String pattern : allowed) {
+            allowedMap.computeIfAbsent(pattern.substring(0, 2), k -> new HashSet<>()).add(pattern.charAt(2));
+        }
+        return canBuildPyramid(bottom);
+    }
+
+    private boolean canBuildPyramid(String bottom) {
+        if (bottom.length() == 1) {
+            return true;
+        }
+        int n = bottom.length();
+        StringBuilder nextRow = new StringBuilder();
+        boolean canBuild = false;
+
+        for (int i = 0; i < n - 1; i++) {
+            String key = bottom.substring(i, i + 2);
+            if (!allowedMap.containsKey(key)) {
+                return false;
+            }
+            for (char topBlock : allowedMap.get(key)) {
+                nextRow.append(topBlock);
+                if (canBuildPyramid(nextRow.toString())) {
+                    canBuild = true;
+                }
+                nextRow.setLength(nextRow.length() - 1); // backtrack
+            }
+        }
+        return canBuild;
+    }
+}

Medium/2025-12-29-756-Pyramid-Transition-Matrix/solution.js

@@ -0,0 +1,32 @@
+var pyramidTransition = function(bottom, allowed) {
+    const allowedMap = new Map();
+    for (const pattern of allowed) {
+        const [left, right, top] = pattern;
+        if (!allowedMap.has(left + right)) {
+            allowedMap.set(left + right, []);
+        }
+        allowedMap.get(left + right).push(top);
+    }
+
+    const canBuild = (currentRow) => {
+        if (currentRow.length === 1) return true;
+        const nextRow = [];
+        for (let i = 0; i < currentRow.length - 1; i++) {
+            const left = currentRow[i];
+            const right = currentRow[i + 1];
+            const key = left + right;
+            if (!allowedMap.has(key)) return false;
+            nextRow.push(allowedMap.get(key));
+        }
+        const buildNextRow = (index) => {
+            if (index === nextRow.length) return canBuild(nextRow);
+            for (const top of nextRow[index]) {
+                if (buildNextRow(index + 1, top)) return true;
+            }
+            return false;
+        };
+        return buildNextRow(0);
+    };
+
+    return canBuild(bottom);
+};

Medium/2025-12-29-756-Pyramid-Transition-Matrix/solution.py

@@ -0,0 +1,38 @@
+class Solution:
+    def pyramidTransition(self, bottom: str, allowed: List[str]) -> bool:
+        from collections import defaultdict
+        
+        # Create a mapping from pairs of blocks to the possible top blocks
+        transitions = defaultdict(set)
+        for pattern in allowed:
+            transitions[pattern[:2]].add(pattern[2])
+        
+        def canBuild(current_row):
+            if len(current_row) == 1:
+                return True
+            
+            next_row = []
+            for i in range(len(current_row) - 1):
+                pair = current_row[i:i+2]
+                if pair not in transitions:
+                    return False
+                next_row.append(transitions[pair])
+            
+            # Use backtracking to explore all combinations of the next row
+            return self.backtrack(next_row, 0, "")
+        
+        return canBuild(bottom)
+    
+    def backtrack(self, next_row, index, current):
+        if index == len(next_row):
+            return self.backtrack(next_row, 0, "")
+        
+        for block in next_row[index]:
+            if index == len(next_row) - 1:
+                if self.backtrack(next_row, index + 1, current + block):
+                    return True
+            else:
+                if self.backtrack(next_row, index + 1, current + block):
+                    return True
+        
+        return False

README.md

@@ -319,3 +319,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-26 — [Minimum Penalty for a Shop](https://leetcode.com/problems/minimum-penalty-for-a-shop/) (Medium) → `Medium/2025-12-26-2483-Minimum-Penalty-for-a-Shop`
 - 2025-12-27 — [Meeting Rooms III](https://leetcode.com/problems/meeting-rooms-iii/) (Hard) → `Hard/2025-12-27-2402-Meeting-Rooms-III`
 - 2025-12-28 — [Count Negative Numbers in a Sorted Matrix](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/) (Easy) → `Easy/2025-12-28-1351-Count-Negative-Numbers-in-a-Sorted-Matrix`
+- 2025-12-29 — [Pyramid Transition Matrix](https://leetcode.com/problems/pyramid-transition-matrix/) (Medium) → `Medium/2025-12-29-756-Pyramid-Transition-Matrix`