From 26085cc027f519b8b91b3d74c5185a982bb6d7ea Mon Sep 17 00:00:00 2001
From: Prad Nukala <prad@sonr.io>
Date: Tue, 22 Sep 2026 12:59:21 -0400
Subject: [PATCH] docs(docs): add Word Ladder and Rotting Oranges documentation
 pages

---
 .../content/graph-bfs/127-word-ladder.mdx     | 67 +++++++++++++++++
 .../content/graph-bfs/994-rotting-oranges.mdx | 72 +++++++++++++++++++
 apps/docs/content/graph-bfs/meta.ts           |  3 +
 3 files changed, 142 insertions(+)
 create mode 100644 apps/docs/content/graph-bfs/127-word-ladder.mdx
 create mode 100644 apps/docs/content/graph-bfs/994-rotting-oranges.mdx
 create mode 100644 apps/docs/content/graph-bfs/meta.ts

diff --git a/apps/docs/content/graph-bfs/127-word-ladder.mdx b/apps/docs/content/graph-bfs/127-word-ladder.mdx
new file mode 100644
index 0000000..9f17708
--- /dev/null
+++ b/apps/docs/content/graph-bfs/127-word-ladder.mdx
@@ -0,0 +1,67 @@
+---
+title: '127. Word Ladder'
+description: 'A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words beginWord -> s1 -> s2 -> ... -> sk such that:'
+sidebar:
+  label: 'Word Ladder'
+  badge: 'Hard'
+---
+
+<Badge variant="accent">Hash Table</Badge>
+
+### Example 1:
+- Input: `beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]`
+- Output: `5`
+- Explanation: One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> cog", which is `5` words long.
+
+### Example 2:
+- Input: `beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]`
+- Output: `0`
+- Explanation: The `endWord` "cog" is not in `wordList`, therefore there is no valid transformation sequence.
+
+### Constraints:
+
+- `1 <= beginWord.length <= 10`
+- `endWord.length == beginWord.length`
+- `1 <= wordList.length <= 5000`
+- `wordList[i].length == beginWord.length`
+- `beginWord`, `endWord`, and `wordList[i]` consist of lowercase English letters.
+- `beginWord != endWord`
+- All the words in `wordList` are unique.
+
+## Solution
+
+```py
+import collections
+
+
+class Solution:
+    def ladderLength(self, beginWord: str, endWord: str, wordList: list[str]) -> int:
+        if endWord not in wordList:
+            return 0
+
+        adj = collections.defaultdict(list)
+        wordList.append(beginWord)
+
+        for word in wordList:
+            for j in range(len(word)):
+                pattern = word[:j] + "*" + word[j + 1 :]
+                adj[pattern].append(word)
+
+        visit = set([beginWord])
+        q = collections.deque([beginWord])
+        res = 1
+
+        while q:
+            for i in range(len(q)):
+                word = q.popleft()
+                if word == endWord:
+                    return res
+                for j in range(len(word)):
+                    pattern = word[:j] + "*" + word[j + 1 :]
+                    for adjWord in adj[pattern]:
+                        if adjWord not in visit:
+                            visit.add(adjWord)
+                            q.append(adjWord)
+            res += 1
+        return 0
+```
diff --git a/apps/docs/content/graph-bfs/994-rotting-oranges.mdx b/apps/docs/content/graph-bfs/994-rotting-oranges.mdx
new file mode 100644
index 0000000..7fd1694
--- /dev/null
+++ b/apps/docs/content/graph-bfs/994-rotting-oranges.mdx
@@ -0,0 +1,72 @@
+---
+title: '994. Rotting Oranges'
+description: 'You are given an m x n grid where each cell can have one of three values:'
+sidebar:
+  label: 'Rotting Oranges'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Array</Badge>
+
+### Example 1:
+- Input: `grid = [[2,1,1],[1,1,0],[0,1,1]]`
+- Output: `4`
+
+### Example 2:
+- Input: `grid = [[2,1,1],[0,1,1],[1,0,1]]`
+- Output: `-1`
+- Explanation: The orange in the bottom left corner (row `2`, column `0`) is never rotten, because rotting only happens 4-directionally.
+
+### Example 3:
+- Input: `grid = [[0,2]]`
+- Output: `0`
+- Explanation: Since there are already no fresh oranges at minute `0`, the answer is just `0`.
+
+### Constraints:
+
+- `m == grid.length`
+- `n == grid[i].length`
+- `1 <= m, n <= 10`
+- grid[i][j] is 0, 1, or 2.
+
+## Solution
+
+```py
+from collections import deque
+
+
+class Solution:
+    def orangesRotting(self, grid: list[list[int]]) -> int:
+        q = deque()
+        time, fresh = 0, 0
+
+        rows, cols = len(grid), len(grid[0])
+        for r in range(rows):
+            for c in range(cols):
+                if grid[r][c] == 1:
+                    fresh += 1
+                if grid[r][c] == 2:
+                    q.append([r, c])
+
+        directions = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+
+        while q and fresh > 0:
+            for i in range(len(q)):
+                r, c = q.popleft()
+                for dr, dc in directions:
+                    row, col = dr + r, dc + c
+                    # check if in bounds
+                    if (
+                        row < 0
+                        or col < 0
+                        or row == len(grid)
+                        or col == len(grid[0])
+                        or grid[row][col] != 1
+                    ):
+                        continue
+                    grid[row][col] = 2
+                    q.append([row, col])
+                    fresh -= 1
+            time += 1
+        return time if fresh == 0 else -1
+```
diff --git a/apps/docs/content/graph-bfs/meta.ts b/apps/docs/content/graph-bfs/meta.ts
new file mode 100644
index 0000000..58d1b88
--- /dev/null
+++ b/apps/docs/content/graph-bfs/meta.ts
@@ -0,0 +1,3 @@
+import { defineMeta } from "blume";
+
+export default defineMeta({ title: "Graph BFS", order: 17 });