[Leetcode 126 & 127, hard & medium] Word Ladder II & I

Problem:

(I): 

Give two words (start and end), and a dictionary. 

(I) Find the length of shortest transformation sequence from start to end, 

(II) 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"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

Analysis:

12XXms

Solutions:

C++:

    bool IsConnected(const string& left, const string& right) 
    {
        int num_diff = 0;
        for(int i = 0; i < left.size(); ++i) {
            if(left[i] != right[i])
                ++num_diff;
                
            if(num_diff > 1)
                return false;
        }

        return num_diff == 1 ? true : false;
    }

    int ladderLength(string start, string end, unordered_set<string> &dict) {
        dict.erase(start);
        dict.erase(end);

        if(dict.size() == 0)
            return 0;
            
        if(IsConnected(start, end))
            return 2;
            
        map<string, int> end_neighbors;
        for(unordered_set<string>::iterator it = dict.begin(); it != dict.end(); ++it) {
            if(IsConnected(*it, end))
                end_neighbors[*it] = 1;
        }

        vector<vector<string> > cached_words_level;
        vector<string> cached_words;
        cached_words.push_back(start);
        cached_words_level.push_back(cached_words);
        for(int level = 0; !cached_words_level[level].empty() ; ++level) {
            cached_words.clear();
            int size_level = cached_words_level[level].size();
            for(int i = 0; i < size_level; ++i) {
                string curr_word = cached_words_level[level][i];
                for(unordered_set<string>::iterator it = dict.begin(); it != dict.end();) {
                    if(IsConnected(*it, curr_word)) {
                        if(end_neighbors[*it] == 1)
                            return level + 3;

                        cached_words.push_back(*it);
                        unordered_set<string>::iterator it_delete = it;
                        ++it;
                        dict.erase(it_delete);
                    } else
                        ++it;
                }
            }
            cached_words_level.push_back(cached_words);
        }
        
        return 0;
    }

Java:

Python: