Word Ladder II

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) 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"]

Return

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

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.    

pro:给一个start的string和一个end的string，求start变化到end的所有最短路径，每一步只能变化一个字母，中间的字符串必须在dict中

sol:bfs，对于一个单词，其每一位能替换成其他的25位，依据这个bfs，最先找到了之后就是最小的步数，但这一层还是要做完以便找到所有的最短路径。

skill：之前一直超时，有两个需要注意的地方能优化，

第一，从end找start，因为记录前驱节点在bfs比较容易，这样就能

第二，先将dict加上start加上end预处理，每个单词能够一步转化到的其他单词，存在一个邻接表中，bfs时快很多

code：

class Solution{public:    void init(string start,string end,unordered_set<string> &dict,vector< vector<string> > &dictvec,map<string,int> &dictindex,map<int,string> &dictvalue)//预处理dict，保存一个邻接表    {        dictindex.clear(),dictvalue.clear();        dictvec.clear();        unordered_set<string>::iterator it;        int cnt=0;        for(it = dict.begin();it!=dict.end();it++)        {            dictindex[*it] = cnt;            dictvalue[cnt++] = *it;        }        if(dict.find(start)==dict.end())        {            dictindex[start] = cnt;            dictvalue[cnt++] = start;        }        if(dict.find(end)==dict.end())        {            dictindex[end] = cnt;            dictvalue[cnt++] = end;        }        int i,j,k;        string front,temp;        char ch;        vector<string> tt;        tt.clear();        for(i=0;i<cnt;i++)        {            tt.clear();            front = dictvalue[i];            temp = front;            for(j=0;j<front.length();j++)            {                for(k=0;k<26;k++)                {                    ch='a'+k;                    if(ch!=front[j])                    {                        temp[j] = ch;                        if(dict.find(temp)!=dict.end()||temp==start||temp==end)                        {                            tt.push_back((temp));                        }                        }                }                temp[j] = front[j];            }            dictvec.push_back(tt);        }    }    vector< vector<string> > findLadders(string start,string end,unordered_set<string> &dict)    {        string sss;        sss=start;        start=end;        end=sss;        vector< vector<string> > dictvec;        map<string,int> dictindex;        map<int,string> dictvalue;        init(start,end,dict,dictvec,dictindex,dictvalue);        vector< vector<string> >myvec;        myvec.clear();        if(start==end)//father记录的是从后往前的，因此end找到start        {            myvec.push_back(vector<string>(2,start));            return myvec;        }        int i,j,k,step;        char ch;        string temp_string,front_string;        //set<string> myset;        map<string,int> mymap;        mymap.clear();        int front_step,front_father,temp_step,temp_father;                vector<string> string_vec;        vector<int> step_vec;        vector< vector<int> > father_vec;        string_vec.clear(),step_vec.clear(),father_vec.clear();        int front,rear;        front=rear=0;        string_vec.push_back(start),step_vec.push_back(1),father_vec.push_back(vector<int>(1,-1));        rear++;        mymap[start]=0;        bool flag=false;        int res;        int end_index=-1;        int end_step=0;        while(front<rear)        {                       front_string = string_vec[front];            int front_index = dictindex[front_string];            //cout<<"&&&"<<front<<' '<<front_string<<endl;            front_step = step_vec[front++];            if(end_index!=-1&&front_step>end_step)                 break;                        for(i=0;i<dictvec[front_index].size();i++)            {                temp_string = dictvec[front_index][i];                                    if((dict.find(temp_string)!=dict.end()||temp_string==end)&&mymap.find(temp_string)!=mymap.end())                        {                            int index=mymap[temp_string];                            if(step_vec[index]==front_step+1)                            {                                father_vec[index].push_back(front-1);                            }                        }                        if (mymap.find(temp_string)==mymap.end()&&(dict.find(temp_string)!=dict.end()||temp_string==end))                       {                            if(temp_string==end)                            {                                end_index=rear;                                end_step=front_step+1;                            }                            mymap[temp_string]=rear;                            string_vec.push_back(temp_string);                            step_vec.push_back(front_step+1);                            father_vec.push_back(vector<int>(1,front-1));                            rear++;                        }            }         }         if(end_index==-1) return myvec;        vector<string> temp;        temp.clear();        temp.push_back(end);        dfs(myvec,end_index,string_vec,father_vec,temp);        //test(father_vec);        return myvec;    }        void dfs(vector< vector<string> > &res,int myfather,vector<string> &string_vec,vector< vector<int> > &father_vec,vector<string> &temp)    {        string tt;        int i,j;        if(myfather==-1)        {            temp.pop_back();            res.push_back(temp);            temp.push_back("hi");        }        else        {            for(i=0;i<father_vec[myfather].size();i++)            {                int index=father_vec[myfather][i];                if(index!=-1)                    temp.push_back(string_vec[index]);                else temp.push_back("hi");                dfs(res,father_vec[myfather][i],string_vec,father_vec,temp);                temp.pop_back();            }        }    }   };