LeetCode 127 Word Ladder (BFS)

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:

1. Only one letter can be changed at a time.
2. 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));
    }
}