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.

struct Node

{

    int vindex;

    int path;

    int previous;

};

class Solution {

public:

    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) 

    {

        vector<vector<string>> result;

        int len=start.length();



        vector<string> vdict;

        map<string,int> ids;

        vdict.push_back(start);

        ids[start]=0;

        for(unordered_set<string>::iterator it=dict.begin();it!=dict.end();it++)

        {

            ids[*it]=vdict.size();

            vdict.push_back(*it);            

        }

        vdict.push_back(end);

        ids[end]=vdict.size()-1;



        dict.insert(start);

        dict.insert(end);



        vector<vector<int>>adj;

        for(int i=0;i<vdict.size();i++)

        {

            vector<int> adj0;

            string str=vdict[i];

            for(int j=0;j<len;j++)

            {

                for(char c='a';c<='z';c++)

                    if(vdict[i][j]!=c)

                    {

                        str[j]=c;

                        if(dict.count(str)) adj0.push_back(ids[str]);                        

                    }

                str[j]=vdict[i][j];

            }

            adj.push_back(adj0);

        }                                

        

        vector<Node*> path;        

        Node* newnode=new Node();

        newnode->vindex=ids[start];

        newnode->path=1;

        newnode->previous=-1;

        path.push_back(newnode);                                    



        int index=0;

        int minpath=0;        

        int oldpath=0;



        while(index<path.size())

        {            

            if(path[index]->path>oldpath)

            {

                oldpath=path[index]->path;

                int i=index;

                while(i<path.size())

                {                    

                    unordered_set<string>::iterator it= dict.find(vdict[path[i]->vindex]);

                    if(it!=dict.end()) dict.erase(it);

                    i++;

                }                

            }

            if(minpath>0 && path[index]->path==minpath)

                break;                

            // a path found

            if(path[index]->vindex==vdict.size()-1)

                minpath=path[index]->path;

            //next word

            for(int i=0;i<adj[path[index]->vindex].size();i++)

            {                   

                if(dict.count(vdict[adj[path[index]->vindex][i]]))

                {                            

                        newnode=new Node();

                        newnode->path=oldpath+1;

                        newnode->vindex=adj[path[index]->vindex][i];

                        newnode->previous=index;

                        path.push_back(newnode);

                }                        

            }

            index++;

        }



        for(int i=0;i<path.size();i++)

        if(path[i]->path==minpath && vdict[path[i]->vindex]==end)

        {

            vector<string> words;

            int index=i;

            do

            {

                words.insert(words.begin(),vdict[path[index]->vindex]);

                index=path[index]->previous;

            }

            while(index!=-1);

            result.push_back(words);

        }

        

        return result;

    }    

};