LeetCode每日一题-单词接龙

单词接龙

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

class Solution {
public:
    //深度优先搜索DFS - 超时
    // bool IsRight(const string& beginWord, const string& str) {
    //     //判断beginword字符串 是否可以变成 str
    //     int count = 0;
    //     for(int i = 0; i < beginWord.size(); i++) {
    //         if(beginWord[i] == str[i]) {
    //             count++;
    //         }
    //     }
    //     return count == beginWord.size() - 1 ? true : false;
    // }

    // void Heapler(const vector<string>& wordList, const string&  endWord, int begin) {
    //     if(begin == wordList.size()) {
    //         //走完了wordlist所有可能 - 退出
    //         if(vec_[vec_.size()-1] == endWord) {
    //             //证明这是一个成功的结果
    //             if(count_ > vec_.size()) { count_ = vec_.size(); }
    //             cout << vec_.size() << endl;
    //         }
    //         return;
    //     }

    //     for(int i = begin; i < wordList.size(); i++) {
    //         //1、能不能让beginword - 变成此时wrodlist[i]字符串
    //         bool flag = false;
    //         if(IsRight(vec_[vec_.size()-1], wordList[i])) {
    //             //可以的
    //             vec_.push_back(wordList[i]);
    //             flag = true;
    //         }
            
    //         Heapler(wordList, endWord, begin+1);

    //         if(flag) {
    //             vec_.pop_back();             //上次在这块保存过， 现在回退
    //         }
    //     }
    // }

    // int ladderLength(string beginWord, string endWord, vector<string>& wordList) {

    //     //1、判断endword是否在wordlist中
    //     int i =  wordList.size() - 1;
    //     for(i; i >= 0; i--) {
    //         if(wordList[i] == endWord) {
    //             break;
    //         }
    //     }

    //     if(i == -1) { return 0; }
    //     swap(wordList[i], wordList[wordList.size()-1]);

    //     vec_.push_back(beginWord);
    //     int begin = 0;
    //     count_ = INT_MAX;
    //     Heapler(wordList, endWord, begin);
    //     return count_ == INT_MAX ? 0 : count_;
    // }

    //广度优先搜索 - BFS - 测试
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        //1、鲁棒性检查

        //2、创建保存资源 - 计数器 + 保存资源 + 回溯队列 + 防止重复筛选set
        unordered_set<string> ust(wordList.begin(), wordList.end());
        ust.erase(beginWord);           //在集合中不能出现重复
        //创建重复筛选set
        unordered_set<string> ust1;
        ust1.insert(beginWord);
        //计数器
        int step = 1;
        //回溯队列
        queue<string> qe;
        qe.push(beginWord);

        //3、广度优先搜索 - BFS
        while(!qe.empty()) {
            int size = qe.size();       //获取这一层次的长度          
            for(int i = 0; i < size; i++) {
                //取出我们需要判断的word
                string curword = qe.front();
                qe.pop();
                //判断我们curword 是否可以通过改变一个单词成立。
                //采用对word每个单词进行26从变化， 判断是否可以成立
                for(int j = 0; j < curword.size(); j++) {
                    char ch_tmp = curword[j];
                    for(int k = 0; k < 26; k++) {                      
                        curword[j] = char('a' + k);
                        if(ust.find(curword) != ust.end() && ust1.find(curword) == ust1.end()) {
                            //在set集合中存在， 但是在set1集合中不存在
                            if(curword == endWord) { return step + 1; }     //证明这次就是我们想要的结果
                            qe.push(curword);   //保存起来， 作为下一次判断的字符
                            ust1.insert(curword);       //添加到set1中 - 防止重复添加
                        }
                    }
                    curword[j] = ch_tmp;          //回退 - 判断下一次字符的变化情况
                }
            }
            step++;
        }
        return 0;           //如果出来 - 证明不能转化成功
    }

private:
    vector<string> vec_;
    int count_;
};

我的题解