solves #127: word ladder in java

Author: anishLearnsToCode

Diff for: README.md

@@ -123,6 +123,7 @@
 | 122  | [Best Time to Buy and Sell Stocks II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii)                                                                |                                          [![Java](assets/java.png)](src/BestTimeToBuyAndSellStockII.java) [![Python](assets/python.png)](python/best_time_to_buy_and_sell_stock_ii.py)                                           |                                                                                                                                   |
 | 123  | [Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum)                                                                             |                                                                                  [![Java](assets/java.png)](src/BinaryTreeMaximumPathSum.java)                                                                                   |                                                                                                                                   |
 | 125  | [Valid Palindrome](https://leetcode.com/problems/valid-palindrome)                                                                                                     |                                                         [![Java](assets/java.png)](src/ValidPalindrome.java) [![Python](assets/python.png)](python/valid_palindrome.py)                                                          |                                                                                                                                   |
+| 127  | [Word Ladder](https://leetcode.com/problems/word-ladder)                                                                                                               |                                                                                         [![Java](assets/java.png)](src/WordLadder.java)                                                                                          |                                                                                                                                   |
 | 128  | [Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence)                                                                             |                                                                                 [![Java](assets/java.png)](src/LongestConsecutiveSequence.java)                                                                                  |                                                                                                                                   |
 | 129  | [Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers)                                                                                     |                                                                                    [![Java](assets/java.png)](src/SumRootToLeafNumbers.java)                                                                                     |                                                                                                                                   |
 | 130  | [Surrounded Regions](https://leetcode.com/problems/surrounded-regions)                                                                                                 |                                                                                      [![Java](assets/java.png)](src/SurroundedRegions.java)                                                                                      |                                                                                                                                   |

Diff for: src/MinimumGeneticMutation.java

@@ -26,21 +26,25 @@ public static int minMutation(String startGene, String endGene, String[] bank) {
         }
 
         final Queue<Info> queue = new LinkedList<>() {{ add(new Info(startGene, 0)); }};
-        final Map<String, Integer> distances = new HashMap<>();
+        final Set<String> visited = new HashSet<>();
 
         while (!queue.isEmpty()) {
             final Info info = queue.poll();
-            if (distances.getOrDefault(info.mutation, Integer.MAX_VALUE) <= info.steps) {
+            if (visited.contains(info.mutation)) {
                 continue;
             }
-            distances.put(info.mutation, info.steps);
+            visited.add(info.mutation);
+
+            if (endGene.equals(info.mutation)) {
+                return info.steps;
+            }
 
             for (String neighbour : validMutations(genePool, info.mutation)) {
                 queue.add(new Info(neighbour, info.steps + 1));
             }
         }
 
-        return distances.getOrDefault(endGene, -1);
+        return -1;
     }
 
     // T: O(|s|), S: O(|s|)

Diff for: src/WordLadder.java

@@ -0,0 +1,58 @@
+// https://leetcode.com/problems/word-ladder
+// T: O(nB + n^m * nm)
+// S: O(nB + n^m)
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+
+public class WordLadder {
+    private record Info(String string, int steps) {}
+
+    // n = possible chars, m = |s|
+    // V = n^m
+    // BFS, T: O(V + E) = O(nB + n^m * nm), S: O(n^m)
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+        final Set<String> words = new HashSet<>(wordList);
+        if (!words.contains(endWord)) {
+            return 0;
+        }
+
+        final Queue<Info> queue = new LinkedList<>() {{ add(new Info(beginWord, 0)); }};
+        final Set<String> visited = new HashSet<>();
+
+        while (!queue.isEmpty()) {
+            final Info info = queue.poll();
+            if (visited.contains(info.string)) {
+                continue;
+            }
+            visited.add(info.string);
+            if (endWord.equals(info.string)) {
+                return info.steps + 1;
+            }
+
+            for (String neighbour : validMutations(words, info.string)) {
+                queue.add(new Info(neighbour, info.steps + 1));
+            }
+        }
+
+        return -1;
+    }
+
+    // T: O(n * m), S: O(n * m)
+    private static List<String> validMutations(Set<String> words, String string) {
+        final List<String> list = new ArrayList<>();
+        for (int i = 0 ; i < string.length() ; i++) {
+            for (char c = 'a' ; c <= 'z' ; c++) {
+                final String word = string.substring(0, i) + c + string.substring(i + 1);
+                if (words.contains(word)) {
+                    list.add(word);
+                }
+            }
+        }
+        return list;
+    }
+}