[LC] 127. Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time.
2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.
• You may assume no duplicates in the word list.
• You may assume beginWord and endWord are non-empty and are not the same.

Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Example 2:

Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

Solution 1:
Time: O(N^2) lead to TLE
Space: O(N)

 class Solution:
     def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
         if beginWord == endWord or endWord not in wordList:
             return 0
         step = 1
         ladder_dict = self.build_dict(beginWord, wordList)
         from collections import deque
         queue = deque([beginWord])
         visited = {beginWord}
         while queue:
             size = len(queue)
             for i in range(size):
                 cur_word = queue.popleft()
                 if cur_word == endWord:
                     return step
                 word_lst = ladder_dict.get(cur_word)
                 for word in word_lst:
                     if word not in visited:
                         queue.append(word)
                         visited.add(word)
             step += 1
         return 0

     def build_dict(self, beginWord, wordList):
         my_dict = {}
         for w_i in wordList:
             my_dict[w_i] = []
             for w_j in wordList:
                 if self.diff(w_i, w_j) == 1:
                     my_dict[w_i].append(w_j)
         if beginWord not in my_dict:
             my_dict[beginWord] = []
             for w_j in wordList:
                 if self.diff(beginWord, w_j) == 1:
                     my_dict[beginWord].append(w_j)
         return my_dict

     def diff(self, s, t):
         count = 0
         for i in range(len(s)):
             if s[i] != t[i]:
                 count += 1
         return count
                     

Solution 2:

Time: O(N * 26^|wordLen|)

Space: O(N)

 class Solution(object):
     def ladderLength(self, beginWord, endWord, wordList):
         """
         :type beginWord: str
         :type endWord: str
         :type wordList: List[str]
         :rtype: int
         """
         if endWord not in wordList:
             return 0
         import string
         from collections import deque
         alpha = string.ascii_lowercase
         queue = deque([beginWord])
         visited = {beginWord}
         word_list = set(wordList)
         step = 1

         while queue:
             size = len(queue)
             for i in range(size):
                 cur_word = queue.popleft()
                 if cur_word == endWord:
                     return step 

                 for i in range(len(cur_word)):
                     for char in alpha:
                         new_word = cur_word[:i] + char + cur_word[i+1: ]
                         if new_word in word_list and new_word not in visited:
                             queue.append(new_word)
                             visited.add(new_word)
             step += 1
         return 0
         

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        int res = 0, len = 1;
        Set<String> dict = new HashSet<>(wordList);
        Queue<String> queue = new LinkedList<>();
        Set<String> visited = new HashSet<>();
        queue.offer(beginWord);
        visited.add(beginWord);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String cur = queue.poll();
                for(String next : getNextWord(cur, dict)) {
                    if (visited.contains(next)) {
                        continue;
                    }
                    if (next.equals(endWord)) {
                        return len + 1;
                    }
                    queue.offer(next);
                    visited.add(next);
                }
            }
            len += 1;
        }
        return 0;
    }

    private List<String> getNextWord(String cur, Set<String> dict) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < cur.length(); i++) {
            char[] charArr = cur.toCharArray();
            for (char j = 'a'; j <= 'z'; j++) {
                if (j == charArr[i]) {
                    continue;
                }
                charArr[i] = j;
                String newString = new String(charArr);
                if (dict.contains(newString)) {
                    list.add(newString);
                }
            }
        }
        return list;
    }
}

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        Queue<String> queue = new LinkedList<>();
        Set<String> set = new HashSet<String>(wordList);
        if (!set.contains(endWord)) {
            return 0;
        }
        int res = 0;
        set.add(endWord);
        queue.offer(beginWord);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String cur = queue.poll();
                if (cur.equals(endWord)) {
                    return res + 1;
                }    

                for (int k = 0; k < cur.length(); k++) {
                    // need to initialize inside of string loop
                    char[] charArr = cur.toCharArray();
                    for (int j = 0; j < 26; j++) {
                        char tmpChar = (char)('a' + j);
                        if (tmpChar == charArr[k]) {
                            continue;
                        }
                        charArr[k] = tmpChar;
                        String tmpStr = new String(charArr);
                        if (set.contains(tmpStr)) {
                            set.remove(tmpStr);
                            queue.offer(tmpStr);
                        }
                    }
                }

            }
            res += 1;
        }
        return 0;
    }
}