leetcode 之 Word Ladder

问题：

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the dictionary

For example,

Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

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.

思路：　从end word开始，孩子节点为end的one letter distance 的word， 采用广度优先遍历，直至发现word that is only one letter distance with start word. 需要注意的是，插入的word不能是之前树中已经有的word。

#include <vector>
#include <queue>
using namespace std;

class Solution {
public:
    bool isOneLetterDiff(const string &d1, const string &d2)
    {
        int count = 0;
        for(int i = 0; i < d1.size() && count < 2; i++)
        {
            if(d1[i] != d2[i]){
                count ++;
            }
        }
        if(count != 1)
            return false;
        return true;
        
    }
    vector<string> * getChildrenSet(const string * node, unordered_set<string> &dict){
        vector<string> * children = new vector<string>();
        for(unordered_set<string>::iterator iter = dict.begin(); iter!= dict.end(); iter++)
        {
            if(isOneLetterDiff(*iter, *node))
            {
                children->push_back(*iter);
            }
        }
        return children;
    }
    
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        //some extreme case. 
        if(dict.size() == 0 || start == end)
            return 0;
        if(isOneLetterDiff(start, end))
            return 2;
            
        queue<string *> tree_queue;
        tree_queue.push(&end);
        string level;
        tree_queue.push(&level);
        dict.erase(end);
        dict.erase(start);
        
        //BFS
        int height = 0;
        while(!tree_queue.empty()){
            string* current = tree_queue.front();
            tree_queue.pop();
            //current height is finished.
            if((*current) == ""){
                height ++;
                //finished.
                if(tree_queue.empty())
                    return 0;
                //not finished.
                else{
                    tree_queue.push(&level);
                    continue;
                }
            }
           
            //insert children.
            vector<string>* children = getChildrenSet(current, dict);
            for(vector<string>::iterator iter = children->begin(); iter!=children->end();iter++)
            {
                if(isOneLetterDiff(*iter, start)){
                    return height + 3;
                }
                tree_queue.push(&(*iter));
                dict.erase(*iter);
            }
        }
        return 0;
    }
};