Word Ladder II

超时：

bool operator <(const pair<string,int> &f, const pair<string, int> &s)
{
	return f.second > s.second;
}

class Solution {
public:
	typedef unordered_map<string,vector<string> > svsmp;
	typedef unordered_map<string,vector<vector<string> > > svvsmp;
	typedef unordered_map<string,int> simp;
	typedef unordered_map<string, bool >sbmp;

	
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        svsmp graph;
		svsmp rt;
		sbmp vst;
		simp dist;
		
		generate_graph(dict, graph);


		for(unordered_set<string>::iterator it = dict.begin(); it != dict.end(); ++it)
		{
			vector<string> gv = graph[*it];
			
			//cout <<*it<<"-->";
			//for(int i = 0; i < gv.size(); i++)cout << gv[i]<< " ";
			//cout<<endl;

			dist[*it] = INT_MAX;
		}

		priority_queue<pair<string, int> >q;
		q.push(make_pair(start, 0));
		dist[start] = 0;
		//vst[start] = true;
		vector<string> v;
		while(!q.empty())
		{
			string from =  q.top().first;
			q.pop();
			if(vst.find(from) != vst.end())
			{
				//cout << from << "===>"<<vst[from]<<endl;
				continue;
			}
			
			vst[from] = true;
			v = graph[from];
			for(int i = 0; i < v.size(); i++)
			{
				string to = v[i];
				if(vst.find(to) != vst.end())continue;
				int distw = dist[from];
				
				
				if(dist[to] > distw + 1)
				{

					dist[to] = distw + 1;
					q.push(make_pair(to, distw + 1));
					vector<string> routev;
					routev.push_back(from);
					rt[to] = routev;
				}
				else if(dist[to] == distw + 1)
					rt[to].push_back(from);
				
				//cout<<endl;
			//	cout << from <<"-->"<< to << dist[to]<<endl;
			}
		}
	
		/*for(unordered_map<string, vector<string> >::iterator it = rt.begin(); it != rt.end(); ++it)
		{
			//cout << it->first<<"=>";
			for(int i = 0; i < (it->second).size(); i++)
				cout << (it->second)[i]<<" ";
			cout << endl;
		}*/
		svvsmp rst;
		return generate_route(rt, end,rst);
		
    }

	vector<vector<string> > generate_route(svsmp &rt, string &end, svvsmp &rst)
	{
		if(rst.find(end) != rst.end())return rst[end];
		vector<vector<string> > rtv;
		vector<string>v;
		if(!rt[end].size())
		{
			v.push_back(end);
			rtv.push_back(v);
			rst[end] = (rtv);
			return rtv;
		}
		
		//v.push_back(end);
		//rtv.push_back(v);
		vector<vector<string> > rtvct;
		//cout << end<<"--->";
		for(int i = 0; i < rt[end].size();i++)
		{
			rtvct = generate_route(rt, rt[end][i], rst);
			for(int j = 0; j < rtvct.size(); j++)
			{
				rtvct[j].push_back(end);
				rtv.push_back(rtvct[j]);
			}
				
		}
		//for(int i = 0; i < rtv.size(); i++)rtv[i].push_back(end);
		//cout<<endl;
		rst[end] = rtv;
		return rtv;
	}

	

	void generate_graph(unordered_set<string> &dict,unordered_map<string, vector<string> > &graph)
	{
		vector<string> v;
		for(unordered_set<string>::iterator it = dict.begin(); it != dict.end(); ++it)
		{
			unordered_set<string>::iterator scd = it;
			for(++scd; scd != dict.end(); ++scd)
			{
				if(could_change(*it, *scd))
				{
					if(graph.find(*it) == graph.end())graph[*it] = v;
					if(graph.find(*scd) == graph.end())graph[*scd] = v;
					graph[*it].push_back(*scd);
					graph[*scd].push_back(*it);
				}
			}
		}
	}

	bool could_change(const string &s1,const string &s2)
	{
		if(s1.size() != s2.size())return false;
		if(!s1.size() || !s2.size())return false;
		int dif = 0;
		for(int i = 0; i < s1.size(); i++)
		{
			if(s1[i] != s2[i])dif++;
			if(dif > 1)return false;
		}
		return true;
	}

};