feat: add 12 more leetcode problems (#134)

Author: wislertt

.claude/.dev/problem_lists/unscrapable.py

@@ -9,6 +9,7 @@
     (261, "graph-valid-tree"),
     (271, "encode-and-decode-strings"),
     (323, "number-of-connected-components-in-an-undirected-graph"),
+    (437, "path-sum-iii"),  # Causing issues with next_problem.py - prefer manual creation
     # Add more unscrapable problems as discovered
 ]
 

.claude/commands/test-quality-assurance.md

@@ -38,13 +38,15 @@ rm -rf leetcode/{problem_name}_backup
 - ❌ **NEVER modify helpers.py manually** - let regeneration handle it
 - ❌ **NEVER skip ty verification** - this is the main CI issue
 - ❌ **NEVER assume tests will pass** - they may fail if solution is incomplete
+- ❌ **NEVER use `null` in JSON templates** - use `None` for Python None values
 
 ### 4. What to Do
 
 - ✅ **ALWAYS use `bake p-gen -p {problem_name} -f`** for regeneration
 - ✅ **ALWAYS verify ty passes** before considering task complete
 - ✅ **ALWAYS restore original solution** after regeneration
 - ✅ **ALWAYS check JSON template** if ty fails (look for `assert_assert_` bugs)
+- ✅ **ALWAYS use `None` not `null` in JSON templates** for Python None values
 
 ## Test Case Standards
 
@@ -57,6 +59,9 @@ rm -rf leetcode/{problem_name}_backup
 
 ### JSON Format
 
+- **CRITICAL**: Use `None` NOT `null` for Python None values in test cases
+    - JSON templates use `None` directly: `"[1, None, 2]"` NOT `"[1, null, 2]"`
+    - This ensures generated Python code passes linting (ruff/ty check for undefined name `null`)
 - Use single quotes for Python strings: `'hello'` not `"hello"`
 - Follow existing parametrize format
 - Ensure valid Python list syntax in test_cases field
@@ -109,6 +114,20 @@ bake p-gen -p {problem_name} -f
 **Expected**: Tests may fail if solution is incomplete (returns 0 or placeholder)
 **Action**: This is normal - focus on ty passing, not test results
 
+### Issue: `null` vs `None` in JSON Templates
+
+**Cause**: JSON template uses `null` which causes linting errors in generated Python code
+
+- Error: `F821 Undefined name 'null'` from ruff/ty
+- Generated test files contain `null` which is not valid Python
+
+**Solution**: Update JSON template to use `None` instead of `null`
+
+- Change: `"([1, null, 2], 3, 1)"` → `"([1, None, 2], 3, 1)"`
+- This applies to `test_cases` list and `playground_setup` fields
+- After fixing JSON, regenerate with `bake p-gen -p {problem_name} -f`
+- Generated code will now pass linting without manual edits
+
 ## Success Criteria
 
 - ✅ **ty passes** with no errors (CRITICAL for CI)

.github/workflows/test-reproducibility.yml

@@ -43,7 +43,7 @@ jobs:
 
             - name: cache-graphviz
               id: cache-graphviz
-              uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
+              uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
               with:
                   path: ~/graphviz-cache
                   key: graphviz-installed-${{ runner.os }}

.github/workflows/test.yml

@@ -58,7 +58,7 @@ jobs:
 
             - name: cache-graphviz
               id: cache-graphviz
-              uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
+              uses: actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
               with:
                   path: ~/graphviz-cache
                   key: graphviz-installed-${{ runner.os }}

bakefile.py

@@ -6,7 +6,7 @@
 from bake import Context, command, console
 from bakelib import PythonLibSpace
 
-PROBLEM = "number_of_connected_components_in_an_undirected_graph"
+PROBLEM = "path_sum_iii"
 problem_option = Annotated[str, typer.Option("-p", "--problem")]
 force_option = Annotated[bool, typer.Option("-f", "--force")]
 

leetcode/cheapest_flights_within_k_stops/README.md

@@ -0,0 +1,64 @@
+# Cheapest Flights Within K Stops
+
+**Difficulty:** Medium
+**Topics:** Dynamic Programming, Depth-First Search, Breadth-First Search, Graph Theory, Heap (Priority Queue), Shortest Path
+**Tags:** algo-master-75
+
+**LeetCode:** [Problem 787](https://leetcode.com/problems/cheapest-flights-within-k-stops/description/)
+
+## Problem Description
+
+There are `n` cities connected by some number of flights. You are given an array `flights` where `flights[i] = [fromi, toi, pricei]` indicates that there is a flight from city `fromi` to city `toi` with cost `pricei`.
+
+You are also given three integers `src`, `dst`, and `k`, return **the cheapest price** from `src` to `dst` with at most `k` stops. If there is no such route, return `-1`.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-3drawio.png)
+
+```
+Input: n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1
+Output: 700
+Explanation:
+The graph is shown above.
+The optimal path with at most 1 stop from city 0 to 3 is marked in red and has cost 100 + 600 = 700.
+Note that the path through cities [0,1,2,3] is cheaper but is invalid because it uses 2 stops.
+```
+
+### Example 2:
+
+![Example 2](https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-1drawio.png)
+
+```
+Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1
+Output: 200
+Explanation:
+The graph is shown above.
+The optimal path with at most 1 stop from city 0 to 2 is marked in red and has cost 100 + 100 = 200.
+```
+
+### Example 3:
+
+![Example 3](https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-2drawio.png)
+
+```
+Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0
+Output: 500
+Explanation:
+The graph is shown above.
+The optimal path with no stops from city 0 to 2 is marked in red and has cost 500.
+```
+
+## Constraints
+
+- 2 <= n <= 100
+- 0 <= flights.length <= (n \* (n - 1) / 2)
+- flights[i].length == 3
+- 0 <= fromi, toi < n
+- fromi != toi
+- 1 <= pricei <= 10^4
+- There will not be any multiple flights between two cities.
+- 0 <= src, dst, k < n
+- src != dst

leetcode/cheapest_flights_within_k_stops/__init__.py

@@ -0,0 +1,10 @@
+def run_find_cheapest_price(
+    solution_class: type, n: int, flights: list[list[int]], src: int, dst: int, k: int
+):
+    implementation = solution_class()
+    return implementation.find_cheapest_price(n, flights, src, dst, k)
+
+
+def assert_find_cheapest_price(result: int, expected: int) -> bool:
+    assert result == expected
+    return True

leetcode/cheapest_flights_within_k_stops/helpers.py

@@ -0,0 +1,33 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.19.1
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_find_cheapest_price, run_find_cheapest_price
+from solution import Solution
+
+# %%
+# Example test case
+n = 4
+flights = [[0, 1, 100], [1, 2, 100], [2, 0, 100], [1, 3, 600], [2, 3, 200]]
+src = 0
+dst = 3
+k = 1
+expected = 700
+
+# %%
+result = run_find_cheapest_price(Solution, n, flights, src, dst, k)
+result
+
+# %%
+assert_find_cheapest_price(result, expected)

leetcode/cheapest_flights_within_k_stops/playground.py

@@ -0,0 +1,30 @@
+from collections import deque
+
+
+class Solution:
+    # Time: O(K * E) where E is number of flights
+    # Space: O(V) where V is number of cities
+    def find_cheapest_price(
+        self, n: int, flights: list[list[int]], src: int, dst: int, k: int
+    ) -> int:
+        # Build adjacency list
+        adj = [[] for _ in range(n)]
+        for from_i, to_i, price_i in flights:
+            adj[from_i].append((to_i, price_i))
+
+        # BFS with stops constraint
+        prices = [float("inf")] * n
+        prices[src] = 0
+        queue = deque([(src, 0, 0)])  # (node, current_price, stops)
+
+        while queue:
+            node, current_price, stops = queue.popleft()
+            if stops > k:
+                continue
+            for neighbor, price in adj[node]:
+                new_price = current_price + price
+                if new_price < prices[neighbor]:
+                    prices[neighbor] = new_price
+                    queue.append((neighbor, new_price, stops + 1))
+
+        return int(prices[dst]) if prices[dst] != float("inf") else -1