leetcode 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

1. Each intermediate word must exist in the dictionary

给定两个单词，和一个词典，找出这两个单词间的所有最短转换，所有的中间转换单词都要在词典中。

由于求得是最短的路径 我们采用宽度优先搜索，当第一次找到的时候,就是最短的路径。

一开始的做法是，用一个队列实现宽度优先遍历，队列中存储着单词和到达这个单词的路径，每次遍历单词的临近单词，若其在词典中，将临近单词和临近单词的路径都压入队列中，但这样会产生超时的错误，因为同一个单词可能会被压入多次，进行了很多多余操作，虽然这不影响结果正确性，却消耗大量时间。

改进的算法，将所有到达某一单词的路径集中映射到单词中，即用hash表存储着所有到达某一单词的所有路径，队列中只存储着单词这个对象。

这此时不会产生多于的寻路。

class Solution {
public:
    bool istransfered(string a,string b){
        int len=a.length();
        int count=0;
       // cout<<a<<" "<<b<<endl;
        for(int i=0;i<len;i++){
            if(a[i]!=b[i]){
                if(count>0)
                    return false;
                count++;
            }
        }
        return true;
    }
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        queue<string> q;
        unordered_map<string,vector<vector<string>>>mq;
        vector<vector<string>>res;
        unordered_map<string,int> m;
        int length=start.size();
        m[start]=0;
        auto it=dict.find(end);
        if(it!=dict.end()){
        	dict.erase(it);
        }
        it=dict.find(start);
        if(it!=dict.end()){
        	dict.erase(it);
        }
       // dict.insert(end);
        q.push(start);
        mq[start].push_back(vector<string>(1,start));
        bool hasfind=false;
        int step;
        while(!q.empty()){
            string cur=q.front();
            vector<vector<string>> &paths=mq[cur];
            q.pop();
            if(hasfind){
                if(paths[0].size()>=step)
                    continue;
            }
            if(istransfered(cur,end)){
            	//std::cout<<cur<<" "<<end<<" size"<<paths[0].size()<<std::endl;
                if(!hasfind){
                	for(int i=0;i<paths.size();i++){
                		paths[i].push_back(end);
                		res.push_back(paths[i]);
                		
                	}
                	hasfind=true;
                	step=paths[0].size();
                }
                else{
                    if(paths[0].size()>=step){
                        continue;
                        
                        
                    }
                    
                	for(int i=0;i<paths.size();i++){
                		paths[i].push_back(end);
                		res.push_back(paths[i]);
                		
                	}
                	if(paths[0].size()<step){
                	    return res;
                	}
                }
                continue;
            }
            auto iter=dict.begin();
            //vector<vector<string >> &paths=mq[cur];
            string curword=cur;
            for(int i=0;i<length;i++){
            	for(char c='a';c<='z';c++){
            		if(cur[i]==c){
            			continue;
            		}
            		curword[i]=c;
            		
            		auto iter=dict.find(curword);
            		if(iter!=dict.end()){
            		
            		auto iit=m.find(curword);
            		if(iit!=m.end()){
            		if(m[curword]<paths[0].size()){
            			continue;
            		}
            		
            		}
            		else{q.push(*iter);}
                    	//cout<<cur<<"  "<<*iter<<endl;
                    	//cout<<paths.size()<<endl;
                   	 	m[*iter]=paths[0].size();
                   	 	
                    	for(int i=0;i<paths.size();i++){
                    		paths[i].push_back(*iter);
                    		mq[*iter].push_back(paths[i]);
                    		paths[i].pop_back();
                    	}
            		}
            	}
            	curword[i]=cur[i];
            	
            }
        
        }
        return res;
    }
};