[leetcode] 127. Word Ladder

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:
Only one letter can be changed at a time.
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.

BFS

使用一个hashmap来记录路径尾部的字符串此时的长度，使用一个queue来记录遍历的字符串
先把begin加入到queue中以及hashmap中，遍历字符串的每个字符，分别用26个字符代替，如果字符串在list中，并且不在hashmap中，就加入queue，并加入hashmap

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> wordSet(wordList.begin(), wordList.end());
        if(!wordSet.count(endWord))
            return 0;
        unordered_map<string, int> pathCnt{{beginWord, 1}};
        queue<string> q;
        q.push(beginWord);
        while(!q.empty()){
            string str = q.front();
            q.pop();
            for(int i=0;i<str.size();i++){
                string cur = str;
                for(char ch='a';ch<='z';ch++){
                    cur[i] = ch;
                    //cout<<cur<<" ";
                    if (wordSet.count(cur) && cur == endWord) 
                        return pathCnt[str] + 1;
                    if (wordSet.count(cur) && !pathCnt.count(cur)) {
                        q.push(cur);
                        pathCnt[cur] = pathCnt[str] + 1;
                    }
                }
            }
        }
        return pathCnt[endWord];
    }
};

也可以直接遍历当前queue的大小，用一个标记来记录层数，遍历的层数就是路径的长度

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> wordSet(wordList.begin(), wordList.end());
        if(!wordSet.count(endWord))
            return 0;
        if(wordSet.count(beginWord))
            wordSet.erase(beginWord);
        queue<string> q;
        q.push(beginWord);
        int res =0;
        while(!q.empty()){
            int size = q.size();
            for(int k=0;k<size;k++){
                string str = q.front();
                q.pop();
                if (str == endWord) return res + 1;
                for(int i=0;i<str.size();i++){
                    string cur = str;
                    for(char ch='a';ch<='z';ch++){
                        cur[i] = ch;
                        if (wordSet.count(cur) && cur != str) {
                            q.push(cur);
                            wordSet.erase(cur);
                        }   
                    }
                }
            }
            res ++;
        }
        return 0;
    }
};

参考

https://www.cnblogs.com/grandyang/p/4539768.html