Leetcode OJ: Word Ladder I/II

Word Ladder

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence 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.

最短距离，直接用BFS暴力解决，直接就过了。比较简单，直接看代码吧：

 

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        unordered_map<string, string> from;
        queue<string> q;
        q.push(start);
        while (!q.empty()) {
            string cur(q.front());
            q.pop();;
            for (int i = 0; i < cur.size(); ++i) {
                string tmp = cur;
                for (char c = 'a'; c <= 'z'; ++c) {
                    if (c != tmp[i]) {
                        cur[i] = c;
                        if (dict.count(cur) == 0 && cur != end)
                            continue;
                        if (cur == end) {
                            int count = 2;
                            cur = tmp;
                            while (cur != start) {
                                cur = from[cur];
                                ++count;
                            }
                            return count;
                        }
                        if (from.count(cur) == 0) {
                            from[cur] = tmp;
                            q.push(cur);
                        }
                    }
                }
                cur[i] = tmp[i];
            }
        }
        
        return 0;
    }
};

760ms过了大数据。

然后就是看重头戏Word Ladder II了！

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.

Word Ladder II与I的区别是，一个是只需要求长度，一个是要求出所有的路径。如何保证能找到所有的路径呢？

假设我们知道最短路径是k，那么到达第k步的节点只可能是深度是k-1的节点，虽然这话很废，但很关键，这一点就要求我们要知道层次信息。

于是，我们就用一个hash表要存已经访问过的节点的层次，还可以用这个表要判断节点是否访问过，当出现我们的目的为止。

接着就是回溯了，回溯的根据还是层次，从end一直往回搜，只找层次相邻的，而变化只有一个字母的节点，直到层次为0。

看代码：

class Solution {
public:
    // 递归实现的查找路径
    void findLaddersHelper(string start, string end, unordered_map<string, int>& depths,
                            vector<vector<string> >& ret, vector<string>& item) {
        if (start == end) {
            // 把路径翻转一下
            reverse(item.begin(), item.end());
            ret.push_back(item);
            reverse(item.begin(), item.end());
            return;
        }
        int curlev = depths[end];
        for (int i = 0; i < end.size(); ++i) {
            string tmp(end);
            for (char c = 'a'; c <= 'z'; ++c) {
                if (c == end[i])
                    continue;
                tmp[i] = c;
                if (depths.count(tmp) == 1 &&
                    depths[tmp] == curlev - 1) {
                    item.push_back(tmp);
                    findLaddersHelper(start, tmp, depths, ret, item);
                    item.pop_back();
                }
            }
        }
    }
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        queue<string> q;
        unordered_map<string, int> depths;
        depths[start] = 0;
        q.push(start);
        vector<vector<string> > ret;
        // 记录一层的长度
        int lastcount = 1;
        int level = 0;
        while (lastcount > 0) {
            // 记录新增层的长度
            int curcount = 0;
            while (lastcount--) {
                string cur(q.front());
                q.pop();
                
                for (int i = 0; i < cur.size(); ++i) {
                    string tmp(cur);
                    for (char c = 'a'; c <= 'z'; ++c) {
                        if (c == cur[i])
                            continue;
                        tmp[i] = c;
                        if (depths.count(tmp) == 0 && (dict.count(tmp) == 1 || tmp == end)) {
                            q.push(tmp);
                            ++curcount;
                            depths[tmp] = level + 1;
                        }
                    }
                }
            }
            if (depths.count(end)) { // 一层结束后，判断是否出现end了
                vector<string> item(1, end);
                findLaddersHelper(start, end, depths, ret, item);
                return ret;
            }
            ++level;
            lastcount = curcount;
        }
        return ret;
    }
};

1200ms过的大数据

这应该算是leetcode上少有的耗时如此之长的题了吧。

最近也拜读了下JULY的程序员编程艺术系列，刚好看到一章讲这题，然后说用双向BFS会好不少，其实也是可以想像的，因为广度优先的话层数越深，广度就越大，而目标只有一个，所以双向至少是去除了一半的计算量，参考JULY书中讲的思路，再结合我原有的单向BFS的代码，于是就有了我自己的双向BFS了。

这里主要注意的是两个问题：

1. 查找的终止条件

2. 如何找出路径

怎么解决？看代码吧~

class Solution {
public:
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        // 用于存状态的一些变量
        queue<string> start_q, end_q;
        unordered_map<string, int> depth_from_start, depth_from_end;
        unordered_set<string> meet;
        depth_from_start[start] = 0;
        depth_from_end[end] = 0;
        int level_from_start = 0, level_from_end = 0, count_from_start = 1, count_from_end = 1;
        start_q.push(start);
        end_q.push(end);
        
        vector<vector<string> > ret;
        
        while (count_from_start > 0 && count_from_end > 0) {
            if (count_from_end < count_from_start) {
                count_from_end = nextLevel(end_q, count_from_end, level_from_end, end,
                        depth_from_end, depth_from_start, meet, dict);
            } else {
                count_from_start = nextLevel(start_q, count_from_start, level_from_start, start,
                        depth_from_start, depth_from_end, meet, dict);
            }
            // 相遇即返回结果
            if (!meet.empty()) {
                for (auto mid : meet) {
                    vector<string> item(1, mid);
                    ret.push_back(item);
                }
                // 找前向的所有路径
                findLaddersHelper(depth_from_start, ret);
                // 翻转
                for (int i = 0; i < ret.size(); ++i) {
                    reverse(ret[i].begin(), ret[i].end());
                }
                // 结合找后向的所有路径
                findLaddersHelper(depth_from_end, ret);
                return ret;
            }
        }
        
        return ret;
    }
private:
    // 对q添加下一层的节点，返回新添加的节点数，并且层数加1
    int nextLevel(queue<string>& q, int qcount, int& level, string& end,
            unordered_map<string, int>& depth, unordered_map<string, int>& other_depth,
            unordered_set<string>& meet, unordered_set<string>& dict) {
        int count = 0;
        while (qcount--) {
            string tmp = q.front();
            q.pop();
            for (int i = 0; i < tmp.size(); ++i) {
                char back = tmp[i];
                for (char c = 'a'; c <= 'z'; ++c) {
                    if (c == back)
                        continue;
                    tmp[i] = c;
                    if (depth.count(tmp) == 0 && (dict.count(tmp) == 1 || tmp == end)) {
                        q.push(tmp);
                        depth[tmp] = level + 1;
                        ++count;
                        // 判断是否与另一个map相交了
                        if (other_depth.count(tmp)) {
                            meet.insert(tmp);
                        }
                    }
                }
                tmp[i] = back;
            }
        }
        ++level;
        return count;
    }
    // 非递归实现的回溯路径，参考JULY的程序员编程艺术
    void findLaddersHelper(unordered_map<string, int>& depth, vector<vector<string> >& ret) {
        vector<vector<string> > temp;
        while (depth[ret.back().back()] != 0) {
            ret.swap(temp);
            ret.clear();
            for (int i = 0; i < temp.size(); ++i) {
                string back = temp[i].back();
                int curlev = depth[back];
                for (int j = 0; j < back.size(); ++j) {
                    char b = back[j];
                    for (char c = 'a'; c <= 'z'; ++c) {
                        if (c == b)
                            continue;
                        back[j] = c;
                        if (depth.count(back) && depth[back] == curlev - 1) {
                            temp[i].push_back(back);
                            ret.push_back(temp[i]);
                            temp[i].pop_back();
                        }
                    }
                    back[j] = b;
                }
            }
        }
    }
};

最终是244ms过了，这提升还是很大的！

这样一下子就把BFS、双BFS、层次搜都过了一遍了，挺不错~