Word Search II

Author: dksifoua

README.md

@@ -47,6 +47,7 @@
 | 0206 | Easy       | Reverse Linked List                                       | Linked List, Recursion                                                      | [solution](./docs/0206-Reverse-Linked-List.md)                                                                    |
 | 0208 | Medium     | Implement Trie (Prefix Tree)                              | Hash Table, String, Design, Trie                                            | [solution](./docs/0208-Implement-Trie-(Prefix-Tree).md)                                                           |
 | 0211 | Medium     | Design Add and Search Words Data Structure                | String, Depth-First Search, Design, Trie                                    | [solution](./docs/0211-Desing-Add-and-Search-Words-Data-Structure.md)                                             |
+| 0212 | Hard       | Word Search II                                            | Array, String, Backtracking, Trie, Matrix                                   | [solution](./docs/0212-Word-Search-II.md)                                                                         |
 | 0217 | Easy       | Contains Duplicate                                        | Array                                                                       | [solution](./docs/0217-Contains-Duplicate.md)                                                                     |
 | 0219 | Easy       | Contains Duplicate II                                     | Array                                                                       | [solution](./docs/0219-Contains-Duplicate-II.md)                                                                  |
 | 0226 | Easy       | Invert Binary Tree                                        | Tree, Depth-First Search, Breadth-First Search, Binary Tree                 | [solution](./docs/0226-Invert-Binary-Tree.md)                                                                     |

docs/0212-Word-Search-II.md

@@ -0,0 +1,50 @@
+# 🧠 [Word Search II](https://leetcode.com/problems/word-search-ii/description/)
+
+## 💡 Intuition
+
+We need to search for all words from a given list that can be formed by traversing adjacent letters on a 2D grid. The
+brute-force approach would involve scanning the board for each word, which is inefficient. Instead, we build a **Trie
+** (prefix tree) from the word list to enable prefix pruning during DFS. This avoids unnecessary traversal and
+accelerates the search significantly.
+
+## 🔍 Approach
+
+1. **Trie Construction**:  
+   We create a Trie data structure where each node represents a character. Words are inserted into this Trie, marking
+   the end of each valid word.
+
+2. **DFS Traversal**:  
+   From every cell on the board, we initiate a DFS. During the traversal:
+    - We check if the current path matches a prefix in the Trie.
+    - If a word is found (a Trie node is marked `end`), we add it to the result set.
+    - To prevent revisiting the same cell, we maintain a set of visited cells.
+    - We perform DFS in four directions: up, down, left, and right.
+
+3. **Optimization**:
+    - Use a `Set` to store results and prevent duplicates.
+    - Stop early in DFS if the prefix is invalid (not in Trie).
+
+## ⏱️ Complexity
+
+- **Time Complexity**:  
+  `O(M × N × 4^L)` in the worst case, where:
+    - `M × N` is the size of the board,
+    - `L` is the length of the longest word,
+    - `4^L` is the number of DFS paths (each cell can branch to 4 neighbors).
+
+  However, due to Trie pruning, the practical complexity is much lower.
+
+- **Space Complexity**:
+    - `O(K × L)` for Trie where `K` is number of words and `L` is average word length.
+    - `O(L)` for the DFS call stack.
+    - `O(W)` for the result set, where `W` is the number of matched words.
+
+## 🧪 Code
+
+- [Java](../src/main/java/io/dksifoua/leetcode/wordsearch2/Solution.java)
+
+## ✅ Summary
+
+Using a Trie to store words allows efficient prefix-based pruning of DFS paths. This avoids redundant searches and
+enables solving the problem within constraints, even for large boards and word lists. Combining Trie with DFS provides a
+powerful pattern for grid-based word search problems.

src/main/java/io/dksifoua/leetcode/wordsearch2/Solution.java

@@ -0,0 +1,77 @@
+package io.dksifoua.leetcode.wordsearch2;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution {
+
+    private Solution[] children;
+    private boolean end;
+
+    public Solution() {
+        this.children = new Solution[26];
+        this.end = false;
+    }
+
+    private void reset() {
+        this.children = new Solution[26];
+        this.end = false;
+    }
+
+    private void insert(String word) {
+        Solution node = this;
+        for (char c : word.toCharArray()) {
+            int index = c - 'a';
+            if (node.children[index] == null) {
+                node.children[index] = new Solution();
+            }
+            node = node.children[index];
+        }
+        node.end = true;
+    }
+
+    public List<String> findWords(char[][] board, String[] words) {
+        this.reset();
+        for (String word : words) {
+            this.insert(word);
+        }
+
+        Set<String> result = new HashSet<>();
+        Set<Tuple<Integer, Integer>> visitedCells = new HashSet<>();
+        for (int row = 0; row < board.length; row++) {
+            for (int col = 0; col < board[row].length; col++) {
+                this.dfs(board, row, col, visitedCells, result, "");
+            }
+        }
+
+        return result.stream().toList();
+    }
+
+    private void dfs(char[][] board, int row, int col, Set<Tuple<Integer, Integer>> visitedCells, Set<String> result, String word) {
+        if (row < 0 || col < 0 || row >= board.length || col >= board[row].length) return;
+
+        int index = board[row][col] - 'a';
+        if (this.children[index] == null) return;
+
+        Tuple<Integer, Integer> cell = new Tuple<>(row, col);
+        if (visitedCells.contains(cell)) return;
+
+        word += board[row][col];
+        visitedCells.add(cell);
+
+        if (this.children[index].end) result.add(word);
+
+        this.children[index].dfs(board, row - 1, col, visitedCells, result, word);
+        this.children[index].dfs(board, row + 1, col, visitedCells, result, word);
+        this.children[index].dfs(board, row, col - 1, visitedCells, result, word);
+        this.children[index].dfs(board, row, col + 1, visitedCells, result, word);
+
+        visitedCells.remove(cell);
+    }
+
+    private static record Tuple<T, U>(T a, U b) {
+    }
+
+    ;
+}

src/test/java/io/dksifoua/leetcode/wordsearch2/SolutionTest.java

@@ -0,0 +1,42 @@
+package io.dksifoua.leetcode.wordsearch2;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SolutionTest {
+
+    @Test
+    void testExample1() {
+        Solution solution = new Solution();
+        char[][] board = {
+                { 'o', 'a', 'a', 'n' },
+                { 'e', 't', 'a', 'e' },
+                { 'i', 'h', 'k', 'r' },
+                { 'i', 'f', 'l', 'v' }
+        };
+        String[] words = { "oath", "pea", "eat", "rain" };
+        List<String> result = solution.findWords(board, words);
+
+        assertTrue(result.contains("oath"));
+        assertTrue(result.contains("eat"));
+        assertEquals(2, result.size());
+    }
+
+    @Test
+    void testExample2() {
+        Solution solution = new Solution();
+        char[][] board = {
+                { 'a', 'b' },
+                { 'c', 'd' }
+        };
+        String[] words = { "abcb" };
+        List<String> result = solution.findWords(board, words);
+
+        assertTrue(result.isEmpty());
+    }
+
+}