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.

typedef struct{
    string myString;
    int step;
}Node;

bool canChange(string first, string second){
    int length = first.length();
    int diff = 0;
    for(int i = 0; i < length; i ++){
        if(first[i] - second[i] != 0){
            diff ++;
            if(diff > 1)
                return false;
        }
    }
//    if(diff == 1)
        return true;
}
class Solution{
    public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList){
        vector<Node> path;
        Node begin = {beginWord, 1};
        path.push_back(begin);
        int start = 0, end = 0;
        int amount = wordList.size();
        bool flag[amount] = {false};

        while(start <= end){
                Node temp = path[start];
                for(int i = 0; i < amount; i ++){
                    if(!flag[i]){
                        if(canChange(temp.myString, wordList[i])){
                            Node node = {wordList[i], temp.step + 1};
                            path.push_back(node);
                            if(node.myString == endWord)
                                return node.step;
                            flag[i] = true;
                            end ++;
                        }
                    }
                }
                start ++;
            }

        Node endNode = path[end];
        if(endNode.myString == endWord)
            return endNode.step;
        else
            return 0;
    }
};