庞果网－－挑战赛之最小操作数

问题描述：

给了A、B两个单词和一个单词集合Dict，每个的长度都相同。我们希望通过若干次操作把单词A变成单词B，每次操作可以改变单词中的一个字母，同时，新产生的单词必须是在给定的单词集合Dict中。求所有行得通步数最少的修改方法。举个例子如下： 

Given:  A = "hit"    B = "cog"    Dict = ["hot","dot","dog","lot","log"] 

Return： [    ["hit","hot","dot","dog","cog"],    ["hit","hot","lot","log","cog"]  ]     

即把字符串A = "hit"转变成字符串B = "cog"，有以下两种可能：

"hit" -> "hot" ->  "dot" ->  "dog" -> "cog"； 

"hit" ->  "hot" ->  "lot" ->  "log"  ->"cog"。 
注：A和B相同的情况下不需要做转换，此时直接返回空集。

哎，下面的代码计算结果应该没问题，但提交以后计算超时……求更快的算法啊

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <set>
#include <map>
#include <deque>
#include <iterator>
#include <algorithm>
using namespace std;


/**
需求：给定一个无向图，指定图中两点，要求输出图中此两点间所有最短路径；
简单的BFS算法不能求出所有的最短路径，本问题解决思路参考：
  算法思想描述：
   1. 整理节点间的关系，为每个节点建立一个集合，该集合中保存所有与该节点直接相连的节点（不包括该节点自身）；
   2. 定义两点一个为起始节点，另一个为终点，求解两者之间的所有路径的问题可以被分解为如下所述的子问题：对每一 个与起始节点直接相连的节点，求解它到终点的所有路径（路径上不包括起始节点）得到一个路径集合，将这些路径集合相加就可以得到起始节点到终点的所有路径；依次类推就可以应用递归的思想，层层递归直到终点，若发现希望得到的一条路径，则转储并打印输出；若发现环路，或发现死路，则停止寻路并返回；
   3. 用栈保存当前已经寻到的路径（不是完整路径）上的节点，在每一次寻到完整路径时弹出栈顶节点；而在遇到从栈顶节点无法继续向下寻路时也弹出该栈顶节点，从而实现回溯。
**/
class Solution
{
public:
    typedef list<string>::iterator listIter;
    vector<vector<string> > findLadders(string start, string end, set<string>& dict)
    {
        vector<vector<string> > result, real_result;
        if(start == end){
            return result;
        }
        //cout<<"sdfsdf"<<endl;
        createNeighbors(start, end, dict);


        findPath(start, "", start, end, result);
        if(result.empty()){
            return result;
        }
        //just keep the shortest path in result;
        vector<vector<string> >::iterator it = result.begin(), it_tmp;
        unsigned u_min = it->size();
        for(++it; it != result.end(); ++it){
            if(it->size() < u_min)
                u_min = it->size();
        }
        it = result.begin();
        for(; it != result.end(); ++it){
            if(it->size() == u_min)
                real_result.push_back(*it);
        }
        return real_result;
    }
private:
    void createNeighbors(string start, string end, set<string>& dict){
        //firstly, store all words into vector
        vector<string> tmpVect;
        tmpVect.push_back(start);
        for(set<string>::iterator siter = dict.begin(); siter != dict.end(); ++siter){
           tmpVect.push_back(*siter);
        }
        tmpVect.push_back(end);


        //then construct the neighbors
        size_t len = tmpVect.size();
        for(size_t i = 0; i < len; ++i){
            for(size_t j = 0; j < len; ++j){
                if(i == j)  continue;
                if(diff(tmpVect[i], tmpVect[j]) == 1u){
                    if(m_neighbors.find(tmpVect[i]) == m_neighbors.end()){
                        m_neighbors[tmpVect[i]] = new list<string>();
                    }
                    m_neighbors[tmpVect[i]]->push_back(tmpVect[j]);
                }
            }
        }
        //print neighbors
        for(map<string, list<string>* >::iterator miter = m_neighbors.begin(); miter != m_neighbors.end(); ++miter){
            cout<<miter->first<<": ";
            for(listIter it = miter->second->begin(); it != miter->second->end(); ++it){
                cout<<*it<<" ";
            }
            cout<<endl;
        }
    }
    //
    unsigned diff(string A, string B){
        size_t len = A.size();
        unsigned uCnt = 0;
        for(size_t i = 0; i < len; ++i){
            if(A[i] != B[i]){
                if(++uCnt > 1)  return 0u;
            }
        }
        return uCnt;
    }
    //
    bool findPath(string current_node, string parent_node,
                  string start_node, string end_node,
                  vector<vector<string> >& result){
        if(!current_node.empty() && !parent_node.empty() && current_node == parent_node){
            return false;
        }
        if(!current_node.empty()){
            m_deque.push_back(current_node);
            if(current_node == end_node){
                result.push_back(vector<string>(m_deque.begin(), m_deque.end()));
                return true;
            }
            else{
                if(m_neighbors.end() == m_neighbors.find(current_node)){
                    return false;
                }
                listIter next_node = m_neighbors[current_node]->begin();
                while(m_neighbors[current_node]->end() != next_node){
                    if(!parent_node.empty()
                       &&(*next_node == parent_node || *next_node == start_node
                          || find(m_deque.begin(), m_deque.end(), *next_node) != m_deque.end()
                         )
                      )
                    {
                        ++next_node;
                        continue;
                    }
                    if(findPath(*next_node, current_node, start_node, end_node, result)){
                        m_deque.pop_back();
                    }
                    ++next_node;
                }
                m_deque.pop_back();
                return false;
            }
        }
        else{
            return false;
        }
    }
private:
    map<string, list<string>* > m_neighbors;
    deque<string> m_deque;
};


int main()
{
    Solution ss;
    set<string> dict;
    dict.insert(string("hot"));
    dict.insert(string("iot"));
    dict.insert(string("iat"));
    dict.insert(string("cat"));
    dict.insert(string("cag"));
    vector<vector<string> > result = ss.findLadders("hit", "cog", dict);
    //print result
    for(size_t idx=0; idx < result.size(); ++idx){
        copy(result[idx].begin(), result[idx].end(), ostream_iterator<string>(cout, ", "));
        cout<<endl;
    }
    return 0;
}
/*
后记：
关于如何求两点间所有的最短路径？
当无向图中两点间最短路径不止一条的时候，如何全部求出这些路径？
答：从其中一点做单源最短路。建立新图，只保留dist(v)-dist(u) = c(u,v)的边，其中c(u,v)是边(u,v)的长度，dist(v), dist(u)为那点到u, v最短路的长度。
然后新图中这两点间所有路径都是这两点间的最短路；
参考：http://www.zhihu.com/question/21138196/answer/17307422

表示没看懂
*/