剑指 Offer II 108. 单词演变

class Solution {
    Map<String, Integer> wordId = new HashMap<String, Integer>();
    List<List<Integer>> edge = new ArrayList<List<Integer>>();
    int nodeNum = 0;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        for (String word : wordList) {
            addEdge(word);
        }
        addEdge(beginWord);
        if (!wordId.containsKey(endWord)) {
            return 0;
        }
        int[] dis = new int[nodeNum];
        Arrays.fill(dis, Integer.MAX_VALUE);
        int beginId = wordId.get(beginWord), endId = wordId.get(endWord);
        dis[beginId] = 0;

        Queue<Integer> que = new LinkedList<Integer>();
        que.offer(beginId);
        while (!que.isEmpty()) {
            int x = que.poll();
            if (x == endId) {
                return dis[endId] / 2 + 1;
            }
            for (int it : edge.get(x)) {
                if (dis[it] == Integer.MAX_VALUE) {
                    dis[it] = dis[x] + 1;
                    que.offer(it);
                }
            }
        }
        return 0;
    }

    public void addEdge(String word) {
        addWord(word);
        int id1 = wordId.get(word);
        char[] array = word.toCharArray();
        int length = array.length;
        for (int i = 0; i < length; ++i) {
            char tmp = array[i];
            array[i] = '*';
            String newWord = new String(array);
            addWord(newWord);
            int id2 = wordId.get(newWord);
            edge.get(id1).add(id2);
            edge.get(id2).add(id1);
            array[i] = tmp;
        }
    }

    public void addWord(String word) {
        if (!wordId.containsKey(word)) {
            wordId.put(word, nodeNum++);
            edge.add(new ArrayList<Integer>());
        }
    }
}

题目的意思是 从 beginword 开始 ，每次从wordlist中寻找出一个 word，他与上一个word只能有一个字母不同，直到找到endword为止，其中不包括beginword的单词总数即为答案(最小值)。

使用广度优先搜索，需要先把问题转化为图的形式。

将每个beginword和wordlist中的每个单词进行编号，并且将每个单词对应的变化中间词(就是将一个单词每一个位置变为*生成的一系列单词)也进行编号，并且生成单词和他的中间词的双向边，用于BFS。

使用队列，先将beginword入队，开始BFS，遍历每一个边，将对应的距离值每次+1。

最后遍历到endword时，返回 距离值/2 + 1 其中 +1 指的是 beginword ， 而对于后续的一系列单词，都是 中间词 ->word -> 中间词 -> word 的形式 遍历的，因此 只考虑word就除以2.

主要难点就是把 单词 和单词之间的联系，转换为图中的结点和边的形式，还需要引入中间词来生成边。

public void addEdge(String word) {
        addWord(word);
        int id1 = wordId.get(word);
        char[] array = word.toCharArray();
        int length = array.length;
        for (int i = 0; i < length; ++i) {
            char tmp = array[i];
            array[i] = '*';
            String newWord = new String(array);
            addWord(newWord);
            int id2 = wordId.get(newWord);
            edge.get(id1).add(id2);
            edge.get(id2).add(id1);
            array[i] = tmp;
        }
    }

    public void addWord(String word) {
        if (!wordId.containsKey(word)) {
            wordId.put(word, nodeNum++);
            edge.add(new ArrayList<Integer>());
        }
    }

上述代码中，addword 函数负责给每个节点编号，且包括中间词也要编号。

addEdge函数先把当前单词进行编号，然后生成这个单词对应的所有中间词，给他们一一编号，然后生成中间词与这个单词的双向边，并进行记录。

这样我们在BFS时，从队列中取出顶部结点，然后就可以通过edge列表，取出这个结点的所有边，然后将到这些边的距离更新，也就是当前距离+1，并把它们加入队列末尾。