DBFS[leetcode 127]

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        return DBFS(beginWord, endWord, wordList);
       // return ladderLength1(beginWord, endWord, wordList);
    }

private:
    int BFS(string beginWord, string endWord, vector<string>& wordList)
    {
        //step1 preprocess the wordlist;
        //对wordList打个表;
        unordered_multimap<string, string> dict;
        //visited实际上是记录访问的;
        unordered_set<string> visited;

        bool isValid = false;
        for (auto& word : wordList) {
            if (word == endWord) isValid = true;
            string str = word;
            for (int i = 0; i < word.size(); i++) {
                //string str = word;
                str[i] = ‘*‘;
                dict.emplace(str, word);
                str[i] = word[i];
            }
        }

        //如果转换表中没有到结果的转换，那么肯定就不行了;
        if (!isValid) return 0;

        //接下来就是BFS套路;
        queue<string> qu;
        qu.push(beginWord);
        int step = 1;
        while(!qu.empty()) {
            step++;
            int len = qu.size();
            while (len--) {
                string cur = qu.front();
                qu.pop();
                for (int i = 0; i < cur.size(); i++) {
                    char tmp = cur[i];
                    cur[i] = ‘*‘;
                    //在dict表中查找;
                    auto range = dict.equal_range(cur);
                    for (auto itr = range.first; itr != range.second; itr++) {
                        if (visited.count(itr->second) == 0) { //当关键字没有被访问时;
                            if (itr->second == endWord) return step;
                            qu.push(itr->second);
                            visited.emplace(itr->second);
                        }
                    }
                    cur[i] = tmp;
                }
            }
        }

        return 0;
    }


int visitWordNode(unordered_multimap<string, string>& dict,  queue<pair<string, int>>& qu, unordered_map<string, int>& start_visited,
            unordered_map<string, int>& end_visited)
{
        
            auto p1 = qu.front();
            auto s1 = p1.first;
            qu.pop();
            for (int i = 0; i < s1.size(); i++) {
                char tmp = s1[i];
                s1[i] = ‘*‘;

                auto range = dict.equal_range(s1);
                for (auto it = range.first; it != range.second; it++) {
                    if (end_visited.find(it->second) != end_visited.end())
                        return p1.second + end_visited[it->second];
                    if (start_visited.find(it->second) == start_visited.end()) {
                        start_visited.emplace(it->second, p1.second +1 );
                        qu.push(make_pair(it->second, p1.second +1));
                    }
                }
                s1[i] = tmp;
            }
            return -1;
}

int DBFS(string beginWord, string endWord, vector<string>& wordList)
{
          //对wordList打个表;
    unordered_multimap<string, string> dict;
        //visited实际上是记录访问的;
    unordered_map<string, int> start_visited;
    unordered_map<string, int> end_visited;

        bool isValid = false;
        for (auto& word : wordList) {
            if (word == endWord) isValid = true;
            string str = word;
            for (int i = 0; i < word.size(); i++) {
                //string str = word;
                str[i] = ‘*‘;
                dict.emplace(str, word);
                str[i] = word[i];
            }
        }

        //如果转换表中没有到结果的转换，那么肯定就不行了;
        if (!isValid) return 0;

        queue<pair<string, int>> s_qu;
        queue<pair<string, int>> e_qu;
        s_qu.push(make_pair(beginWord, 1));
        e_qu.push(make_pair(endWord, 1));

        end_visited.emplace(endWord, 1);
        start_visited.emplace(beginWord, 1);


        int step = 1;
        while (!s_qu.empty() && !e_qu.empty()) {
           int ans = visitWordNode(dict, s_qu, start_visited, end_visited);
           if (ans > -1) {
               return ans;
           }

           ans = visitWordNode(dict, e_qu, end_visited, start_visited);
           if (ans > -1) {
               return ans;
           }
        }

        return 0;
}

};

总的来说DBFS相对麻烦一点，多练练就好了

DBFS[leetcode 127]

原文：https://www.cnblogs.com/zhanghanLeo/p/13277116.html