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.

   struct node
   {
     int cost;
     string s;
   };

   struct mycompare{
     bool operator()(node &a, node &b) const
     {
        return (a.cost > b.cost);
     }
   };
   #define INT_MAX 0x7FFFFFFF

   bool canTrans(string a, string b){  
     int dif = 0;  
     for (int i = 0; i < a.length(); i++){  
       if (a[i] != b[i]){  
         dif++;  
         if (dif >= 2){  
           return false;  
         }  
       }  
     }  
     return true;  
   }



   int ladderLength(string start, string end, unordered_set<string> &dict) {  
     queue<string> wq;  
     queue<int> lq;  
     wq.push(start);  
     lq.push(1);  
     while (!wq.empty()){  
       string word(wq.front());  
       wq.pop();  
       int lev = lq.front();  
       lq.pop();  
       for (int i = 0; i < word.length(); i++){  
         char temp = word[i];  
         for (char c = 'a'; c <= 'z'; c++){  
           word[i] = c;  
           if (word == end){  
             return lev + 1;  
           }  
           if (dict.find(word) != dict.end()){  
             wq.push(word);  
             lq.push(lev + 1);  
             dict.erase(word);  
           }  
           word[i] = temp;  
         }  
       }  
     }  
     return 0;  
   }