[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;
    }
}