leetcode Word Ladder II

先用bfs得出最短路径长度，在bfs过程中，可以得到每一层有多少个结点可以到达，也就是在最短走k步的情况下，到达的结点，这样待会在求所有路径的时候就可以剪枝。。。

vector<int> edge[1000000];

set<int>  censhu[10000];
class Solution {
public:
    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        dict.insert(start);
        dict.insert(end);
        int  n = dict.size();
        int st = -1,ed = -1;
        a.clear();
        map<string ,int> mp;
        int cnt = 0;
        for(unordered_set<string>::iterator it = dict.begin();it!=dict.end();++it){
            a.push_back(*it);
            mp[*it] = cnt++;
        }
        for(int i = 0;i<n;i++)edge[i].clear(),censhu[i].clear();
        for(int i = 0;i<n;i++){
            if(a[i]==start)st = i;
            if(a[i]==end)ed = i;
            dict.erase(a[i]);
            unordered_set<string>::iterator it;
            for(int j = 0;j<a[i].size();j++){
                string s =a[i];
                for(int k = 0;k<26;k++){
                    s[j] = 'a'+k;
                    if((it = dict.find(s))!=dict.end()){
                        edge[i].push_back(mp[*it]);
                        edge[mp[*it]].push_back(i);
                    }
                }
            }
        }
        queue<int>  qe[2];
        //bool *visit = new visit[n];
        int *d = new int[n];
        for(int i = 0;i<n;i++)d[i] = -1;
        d[st] = 0;
        qe[0].push(st);
        int loca = 0;
        ans = -1;
        queue<int>  qe2;
        censhu[0].insert(st);
        while(!qe[loca].empty()){
            while(!qe[loca].empty()){
                int p = qe[loca].front();
                if(p==ed){
                    ans = d[ed];
                    break;
                }
                qe[loca].pop();
                for(int i = 0;i<edge[p].size();i++){
                    int u = edge[p][i];
                    if(d[u]==-1){
                        d[u] = d[p]+1;
                        qe[1-loca].push(u);
                        censhu[d[u]].insert(u);
                    }
                }
            }
            if(ans!=-1)break;
            loca = 1-loca;
        }
        vector< vector<string> >result;
        if(ans==-1)return result;
        vector<int>  r;
        r.push_back(st);
        for(int i = 0;i<n;i++)d[i] = -1;
        d[st] = 1;
        dfs(st,ed,result,r,0,d);
        delete []d;
        return result;
    }
private:
    void dfs(int from,int ed,vector< vector<string> >&result,vector<int>  &r,int num,int *d){
        if(from==ed){
            vector<string> s;
            for(int i = 0;i<r.size();i++)s.push_back(a[r[i]]);
            result.push_back(s);
            return ;
        }
        for(int i = 0;i<edge[from].size();i++){
            int u = edge[from][i];
            if(d[u]==-1 && num<ans && censhu[num+1].find(u)!=censhu[num+1].end()){
                d[u] = 1;
                //vector<int> rr(r);
                r.push_back(u);
                dfs(u,ed,result,r,num+1,d);
                r.pop_back();
                d[u] = -1;
            }
        }
    }
bool check(int i,int j){
    int ok = 1;
    int l = a[i].size();
    for(int k = 0;k<l;k++){
        if(a[i][k]!=a[j][k]){
            if(!ok)return false;
            ok = 0;
        }
    }
    return true;
    }
    vector<string>  a;
    int ans;
};