leetcode[126]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.

class Solution {

public:

void dfs(vector<vector<string>> &res,vector<string> str,unordered_map<string,vector<string>> &father,string start, string now)

{

    if(now==start)

    {

        str.push_back(now);

        res.push_back(str);

        reverse(res.back().begin(),res.back().end());

        return;

    }

    for(const auto &x : father[now])

    {

        str.push_back(now);

        dfs(res,str,father,start,x);

        str.pop_back();

    }

}

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

        vector<vector<string>> res;

        if(start==end)return res;

        unordered_set<string> curr,next;

        unordered_set<string> all;

        unordered_map<string,vector<string>> father;

        bool found=false;

        curr.insert(start);

        while(!curr.empty()&&!found)

        {

            for(const auto &x : curr)

            {

                all.insert(x);

            }

            for(const auto &x : curr)

            {

                for(int i=0;i<x.length();i++)

                {

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

                    {

                        if(x[i]==char(j))continue;

                        string tx=x;

                        tx[i]=char(j);

                        if(tx==end)found=true;

                        if(dict.find(tx)!=dict.end()&&all.find(tx)==all.end())

                        {

                            next.insert(tx);

                            father[tx].push_back(x);

                        }

                    }

                }

            }

            curr.clear();

            swap(curr,next);

        }

        vector<string> str;

        dfs(res,str,father,start,end);

    }

};