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
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 {
private:
    vector<vector<string>> res;
public:
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        res.clear();
        
        unordered_map<string, vector<string> > paths;
        
        queue<string> que;
        
        que.push(start);
        dict.insert(end);
        
        vector<string> del;
        del.push_back(start);
        
        while (!que.empty()) {
            int size = que.size();
            
            for (string& s : del) {
                dict.erase(s);
            }
            
            del.clear();
            
            for (int i=0; i<size; i++) {
            
                string str = que.front();
                string orig = str;
                que.pop();
            
                if (str == end) {
                    continue;
                }
                for (char& ch : str) {
                    for (char c = 'a'; c <= 'z'; c++) {
                        if (ch == c) {
                            continue;
                        }
                        char t = ch;
                        ch = c;
                    
                        if (dict.count(str) > 0) {
                            del.push_back(str);
                            que.push(str);
                        
                            if (paths.count(str) == 0) {
                                paths.insert(make_pair(str, vector<string>()));
                            }
                            paths[str].push_back(orig);
                        }
                        ch = t;
                    }
                }
            }
        }
        vector<string> path;
        path.push_back(end);
        build_path(paths, path, end);
        return res;
    }
    
    void build_path(unordered_map<string, vector<string> > paths, vector<string>& path, string prev) {
        if (paths.count(prev) == 0) {
            if (path.size() < 2) return;
            reverse(path.begin(), path.end());
            res.push_back(path);
            return;
        }
        
        vector<string>& strs = paths[prev];
        for (string& s : strs) {
            path.push_back(s);
            build_path(paths, path, s);
            path.pop_back();
        }
    }
};

TLE