[LeetCode] 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.

 

因为之前一直没自己写过Dijkstra算法，而且最开始感觉这题就是先转成图再用Dijkstra求最短路径，所以就一直没做，昨天复习了一下Dijkstra算法，打算把这题A掉，没想到居然爆内存了。

网上搜了下别人的代码，发现不用先转化成图，求边的时候直接枚举‘a’到‘z’就可以了，然后BFS。

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        if (start.length() != end.length()) return 0;
        if (start.empty() || end.empty()) return 0;
        queue<string> path;
        path.push(start);
        dict.erase(start);
        int len = 1, cnt = 1;
        while (!dict.empty() && !path.empty()) {
            string cur = path.front();
            path.pop();
            --cnt;
            for (int i = 0; i < cur.size(); ++i) {
                string tmp = cur;
                for (char j = 'a'; j <= 'z'; ++j) {
                    if (tmp[i] == j) continue;
                    tmp[i] = j;
                    if (tmp == end) return len + 1;
                    if (dict.find(tmp) != dict.end()) {
                        path.push(tmp);
                        dict.erase(tmp);
                    }
                }
            }
            if (cnt == 0) {
                ++len;
                cnt = path.size();
            }
        }
        return 0;
    }
};

下面是Dijsktra算法，不过超内存了。

class Solution {
public:
    bool match(const string &s1, const string &s2) {
        if (s1.length() != s2.length()) return false;
        int cnt = 0;
        for (int i = 0; i < s1.length(); ++i) {
            if (s1[i] != s2[i]) ++cnt;
            if (cnt > 1) return false;
        }
        return cnt == 1 ? true : false;
    }
    
    void buildGraph(vector<vector<int> > &graph, unordered_set<string> &dict, string start, string end, int &start_idx, int &end_idx) {
        dict.insert(start);
        dict.insert(end);
        vector<string> str_idx(dict.size());
        int idx = 0;
        for (auto i : dict) {
            str_idx[idx] = i;
            if (i == start) start_idx = idx;
            if (i == end) end_idx = idx;
            ++idx;
        }
        graph.assign(str_idx.size(), vector<int>(str_idx.size(), INT_MAX));
        for (int i = 0; i < str_idx.size(); ++i) {
            for (int j = 0; j < str_idx.size(); ++j) {
                if (match(str_idx[i], str_idx[j])) {
                    graph[i][j] = graph[j][i] = 1;
                }
            }
        }
    }
    
    int dijkstra(vector<vector<int> > &graph, int start_idx, int end_idx) {
        int N = graph.size();
        vector<bool> s(N, false);
        vector<int> dist(N, 0);
        int u = start_idx;
        for (int i = 0; i < N; ++i) {
            dist[i] = graph[start_idx][i];
        }
        dist[start_idx] = 0;
        s[start_idx] = true;
        for (int i = 0; i < N; ++i) {
            int tmp_max = INT_MAX;
            for (int j = 0; j < N; ++j) {
                if (!s[j] && tmp_max > dist[j]) {
                    u = j;
                    tmp_max = dist[j];
                }
            }
            s[u] = true;
            if (u == end_idx) return dist[u] + 1;
            for (int j = 0; j < N; ++j) {
                if (!s[j] && graph[u][j] < INT_MAX) {
                    dist[j] = min(dist[j], dist[u] + graph[u][j]);
                }
            }
        }
    }
    
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        vector<vector<int> > graph;
        int start_idx, end_idx;
        buildGraph(graph, dict, start, end, start_idx, end_idx);
        return dijkstra(graph, start_idx, end_idx);
    }
};