Word Ladder系列

1.Word Ladder

问题描述：

给两个word（beginWord和endWord）和一个字典word list，找出从beginWord到endWord之间的长度最长的一个序列，条件：

1.字典中的每个单词只能使用一次；

2.序列中的每个单词都必须是字典中的单词；

例如：

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

注意：

　　如果找不到合适的序列，返回0；

　　所有的单词长度都是一样的；

所有的单词都只由小写字母组成。

思路：

采用DFS依次遍历

代码如下：

 class Solution {
 public:
     int ladderLength(string beginWord, string endWord, unordered_set<string>& wordDict) {
         unordered_set<string> s1 = {beginWord}; // Front end
         unordered_set<string> s2 = {endWord}; // Back end
         wordDict.erase(beginWord);
         wordDict.erase(endWord);

         return ladderLength(s1, s2, wordDict, );
     }

 private:
     int ladderLength(unordered_set<string>& s1, unordered_set<string>& s2, unordered_set<string>& wordDict, int level) {
         if (s1.empty()) // We can't find one.
             return ;
         unordered_set<string> s3; // s3 stores all words 1 step from s1.
         for (auto word : s1) {
             for (auto& ch : word) {
                 auto originalCh = ch;
                 for (ch = 'a'; ch <= 'z'; ++ ch) {
                     if (ch != originalCh) {
                         if (s2.count(word))  // We found one.
                             return level + ;
                         if (wordDict.count(word)) {
                             wordDict.erase(word); // Avoid duplicates.
                             s3.insert(word);
                         }
                     }
                 }

                 ch = originalCh;
             }
         }
         // Continue with the one with smaller size.
         return (s2.size() <= s3.size()) ? ladderLength(s2, s3, wordDict, level + ) : ladderLength(s3, s2, wordDict, level + );
     }
 };

1.Word Ladder II

问题描述：给两个word（beginWord和endWord）和一个字典word list，找出从beginWord到endWord之间所有长度最短的序列，条件：

1.一次只能改变一个字符

2.每个中间的单词必须在字典中

思路:

Treat each word as a node of a tree. There are two trees. One tree's root node is "beginWord", and the other tree's root node is "endWord".

The root node can yield all his children node, and they are the second layer of the tree. The second layer can yield all their children, then we get the third layer of the tree, ... , and so on.

When one tree yield a new child, we search it in the last layer of the other tree. If we find an identical node in that tree, then we get some ladders connect two roots("beginWord" -> ... -> "endWord").

Another thing should be considered is: two(or more) different nodes may yield an identical child. That means the child may have two(or more) parents. For example, "hit" and "hot" can both yield "hat", means "hat" has two parents.

So, the data struct of tree-node is:

 class Node {
 public:
     string word;
     vectror<Node*> parents;
     Node(string w) : word(w) {}
 }

Note: we don't need a children field for Node class, because we won't use it.

Two nodes are considered equal when their word field are equal. So we introduce an compare function:

 bool nodecmp(Node* pa, Node* pb)
 {
     return pa->word < pb->word;
 }

Then we use nodecmp as the compare function to build a node set.

 typedef bool (*NodeCmper) (Node*, Node*);
 typedef set<Node*, NodeCmper> NodeSet;
 NodeSet layer(nodecmp);

Then we can store/search pointers of nodes in node set layer. For example:

 Node node1("hit"), node2("hot"), node3("hat");
 layer.insert(&node1);
 layer.insert(&node2);
 layer.insert(&node3);
 auto itr = layer.find(new Node("hot"));
 cout << (*itr)->word; // output: hot

Using these data structures, we can solve this problem with bi-direction BFS algorithm. Below is the AC code, and it is very very fast.

 class Node;

 typedef vector<string> Ladder;
 typedef unordered_set<string> StringSet;
 typedef bool (*NodeCmper) (Node*, Node*);
 typedef set<Node*, NodeCmper> NodeSet;

 class Node
 {
 public:
     string word;
     vector<Node*> parents;

     Node(string w) : word(w) {}
     void addparent(Node* parent) { parents.push_back(parent); }

     // Yield all children of this node, and:
     //   1) If the child is found in $targetlayer, which means we found ladders that
     //      connect BEGIN-WORD and END-WORD, then we get all paths through this node
     //      to its ROOT node, and all paths through the target child node to its ROOT
     //      node, and combine the two group of paths to a group of ladders, and append
     //      these ladders to $ladders.
     //   2) Elif the $ladders is empty:
     //       2.1) If the child is found in $nextlayer, then get that child, and add
     //            this node to its parents.
     //       2.2) Else, add the child to nextlayer, and add this node to its parents.
     //   3) Else, do nothing.
     void yieldchildren(NodeSet& nextlayer, StringSet& wordlist, NodeSet& targetlayer,
                        vector<Ladder>& ladders, bool forward)
     {
         string nextword = word;
         for (int i = , n = nextword.length(); i < n; i++) {
             char oldchar = nextword[i];
             for (nextword[i] = 'a'; nextword[i] <= 'z'; nextword[i]++) {
                 if (wordlist.count(nextword)) {
                     // now we found a valid child-word, let's yield a child.
                     Node* child = new Node(nextword);
                     yield1(child, nextlayer, targetlayer, ladders, forward);
                 }
             }
             nextword[i] = oldchar;
         }
     }

     // yield one child, see comment of function `yieldchildren`
     void yield1(Node* child, NodeSet& nextlayer, NodeSet& targetlayer,
                 vector<Ladder>& ladders, bool forward) {
         auto itr = targetlayer.find(child);
         if (itr != targetlayer.end()) {
             for (Ladder path1 : this->getpaths()) {
                 for (Ladder path2 : (*itr)->getpaths()) {
                     if (forward) {
                         ladders.push_back(path1);
                         ladders.back().insert(ladders.back().end(), path2.rbegin(), path2.rend());
                     } else {
                         ladders.push_back(path2);
                         ladders.back().insert(ladders.back().end(), path1.rbegin(), path1.rend());
                     }
                 }
             }
         } else if (ladders.empty()) {
             auto itr = nextlayer.find(child);
             if (itr != nextlayer.end()) {
                 (*itr)->addparent(this);
             } else {
                 child->addparent(this);
                 nextlayer.insert(child);
             }
         }
     }

     vector<Ladder> getpaths()
     {
         vector<Ladder> ladders;
         if (parents.empty()) {
             ladders.push_back(Ladder(, word));
         } else {
             for (Node* parent : parents) {
                 for (Ladder ladder : parent->getpaths()) {
                     ladders.push_back(ladder);
                     ladders.back().push_back(word);
                 }
             }
         }
         return ladders;
     }
 };

 bool nodecmp(Node* pa, Node* pb)
 {
     return pa->word < pb->word;
 }

 class Solution {
 public:
     vector<Ladder> findLadders(string begin, string end, StringSet& wordlist) {
         vector<Ladder> ladders;
         Node headroot(begin), tailroot(end);
         NodeSet frontlayer(nodecmp), backlayer(nodecmp);
         NodeSet *ptr_layerA = &frontlayer, *ptr_layerB = &backlayer;
         bool forward = true;

         if (begin == end) {
             ladders.push_back(Ladder(, begin));
             return ladders;
         }

         frontlayer.insert(&headroot);
         backlayer.insert(&tailroot);
         wordlist.insert(end);
         while (!ptr_layerA->empty() && !ptr_layerB->empty() && ladders.empty()) {
             NodeSet nextlayer(nodecmp);
             if (ptr_layerA->size() > ptr_layerB->size()) {
                 swap(ptr_layerA, ptr_layerB);
                 forward = ! forward;
             }
             for (Node* node : *ptr_layerA) {
                 wordlist.erase(node->word);
             }
             for (Node* node : *ptr_layerA) {
                 node->yieldchildren(nextlayer, wordlist, *ptr_layerB, ladders, forward);
             }
             swap(*ptr_layerA, nextlayer);
         }

         return ladders;
     }
 };