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.

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]
As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

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.
UPDATE (2017/1/20):
The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

题意

每次只能更改一个字母,求通过wordList 中的单词从startword到endword的变换所需要的最少步数

分析

通过BFS, 每次扩展的下一层是只与当前相差1个字母未被使用过的单词, 一个单词被扩展之后, 就从wordList中删除, (因为如果之后还会扩展到这个单词, 步数肯定不比之前扩展到的少.), 直到找到endword或者不能再做BFS.

实现

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        queue<string> q;
        string cur;
        q.push(beginWord);
        int level = 0;
        while (!q.empty()) {
            int n = q.size();
            level++;
            while (n--) {
                cur = q.front();
                for (auto it = wordList.begin(); it!=wordList.end();) {
                    if (diffence(cur, *it) == 1) {
                        if (*it == endWord) 
                            return level+1;
                        q.push(*it);
                        it = wordList.erase(it);
                    } else it++;
                }
                q.pop();
            }
        }
        return 0;
    }

    int diffence(string& a, string& b) {
        int diff = 0;
        for (int i = 0; i < a.size() && i< b.size(); i++) 
            if (a[i] != b[i]) diff++;
        return diff + abs(a.size()-b.size());
    }
};