Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:
- Only one letter can be changed at a time.
- Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
Note:
- Return 0 if there is no such transformation sequence.
- All words have the same length.
- All words contain only lowercase alphabetic characters.
- You may assume no duplicates in the word list.
- You may assume beginWord and endWord are non-empty and are not the same.
Example 1:
Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"] Output: 5 Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog", return its length 5.
Example 2:
Input: beginWord = "hit" endWord = "cog" wordList = ["hot","dot","dog","lot","log"] Output: 0 Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
题目链接:https://leetcode.com/problems/word-ladder/
题目分析:常规操作,字符串hash成数字,根据题意连边,然后就是一个最短路问题
233ms,时间击败27.8%,待优化
class Solution {
public final int MAX = 50000;
public int[] head = new int[MAX];
public int cnt = 0;
HashMap<String, Integer> strHash = new HashMap<>();
public boolean isLinked(String w1, String w2) {
int eq = 1;
for (int i = 0; i < w1.length(); i++) {
if (w1.charAt(i) == w2.charAt(i)) {
continue;
}
eq--;
if (eq == -1) {
return false;
}
}
return true;
}
public class Edge {
public int to;
public int nxt;
public Edge(){}
public Edge(int to, int nxt) {
this.to = to;
this.nxt = nxt;
}
}
public Edge[] e = new Edge[MAX];
public void Init() {
cnt = 0;
Arrays.fill(head, -1);
for (int i = 0; i < MAX; i++) {
e[i] = new Edge();
}
}
public void Add(int u, int v) {
e[cnt].to = v;
e[cnt].nxt = head[u];
head[u] = cnt++;
e[cnt].to = u;
e[cnt].nxt = head[v];
head[v] = cnt++;
}
public int BFS(int st, int ed) {
boolean vis[] = new boolean[MAX];
Queue<int[]> q = new LinkedList();
q.add(new int[]{st, 1});
vis[st] = true;
while (!q.isEmpty()) {
int[] cur = q.poll();
if (cur[0] == ed) {
return cur[1];
}
for (int i = head[cur[0]]; i != -1; i = e[i].nxt) {
int v = e[i].to;
if (!vis[v]) {
vis[v] = true;
q.add(new int[]{v, cur[1] + 1});
}
}
}
return 0;
}
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
int num = 1;
strHash.put(beginWord, 0);
for (int i = 0; i < wordList.size(); i++) {
strHash.put(wordList.get(i), num++);
}
Init();
for (int i = 0; i < wordList.size(); i++) {
for (int j = i + 1; j < wordList.size(); j++) {
if (isLinked(wordList.get(i), wordList.get(j))) {
int x = strHash.get(wordList.get(i));
int y = strHash.get(wordList.get(j));
Add(x, y);
}
}
}
for (int i = 0; i < wordList.size(); i++) {
if (isLinked(beginWord, wordList.get(i))) {
int x = strHash.get(wordList.get(i));
Add(0, x);
}
}
if (!strHash.containsKey(endWord)) {
return 0;
}
return BFS(0, strHash.get(endWord));
}
}