【Lintcode】120. Word Ladder

题目地址：

https://www.lintcode.com/problem/word-ladder/description

字符串的路径搜索问题。给定一个起点字符串和终点字符串，然后给一个集合dict，从起点字符串开始，每次可以变更字符串中的某一位置的字符成为另一个字符，这样得到另一个字符串，如果这个字符串在dict里，我们就说这样的变化是合法的。问从起点字符串起，做连续的合法变换，至少变换多少步，就可以得到终点字符串，返回路径节点个数（所以返回的其实是路径长度 + 1）。其余的assumption有：dict里每个单词长度相同，只含小写字母，dict里无重复，并且start和end不相等。

此题本质上是图论的BFS问题。我们可以在做BFS的时候，每遍历到一个字符串，就先求出它的“未访问的邻居“是哪些，然后逐次向后走，直到恰好走到终点字符串的时候，就返回走过的步数。代码如下：

import java.util.*;

public class Solution {
    /*
     * @param start: a string
     * @param end: a string
     * @param dict: a set of string
     * @return: An integer
     */
    public int ladderLength(String start, String end, Set<String> dict) {
        // write your code here
        // 判空
        if (dict == null || dict.isEmpty()) {
            return 0;
        }
        
		// dict只存start的未访问的邻居就可以了，一开始可以把start删掉。（由于题目里说明了start与end不同，所以不删的话程序也是对的，此处随意）
		dict.remove(start);
        // 将end加入dict，因为end完全可能作为BFS时某个节点的下一步的节点出现
        dict.add(end);
        
        // queue储存路径上距离start相等的节点
        Queue<String> queue = new LinkedList<>();
        // 先把起点加进queue
        queue.offer(start);
        
        // 初始化len为1，因为需要返回的是路径的节点个数，起始节点已经算1了
        int len = 1;
        while (!queue.isEmpty()) {
        	// 向邻边走一步
            len++;
            // BFS需要记录一下队列里的节点个数，以方便知道当前处于哪一层
            int size = queue.size();
            for (int i = 0; i < size; i++) {
            	// 从队列里取出一个节点开始访问
                String word = queue.poll();
                // 得到它的未访问过的邻居，并对这些邻居进行遍历
                for (String nextWord : getNextWordsAndRemove(word, dict)) {
                   	// 如果这个邻居已经等于终点了，说明已经找到一条路径了，
                   	// 并且它一定也是最短的，直接返回len
                    if (nextWord.equals(end)) {
                    	return len;
                    }
                    
                   	// 否则把这个邻居加进队列，即向外扩张一步
                    queue.offer(nextWord);
                }
            }
        }
        
        // 如果没找到到达end的路径，返回0表示不存在这样的路径
        return 0;
    }
    
    // 得到word的邻居，并将它的邻居从dict里全部删掉
    private List<String> getNextWordsAndRemove(String word, Set<String> dict) {
        List<String> nextWords = new ArrayList<>();
        // 将word每个位置替换为别的字母，然后看它是否在dict里；如果在，说明得到了一个邻居
        for (char c = 'a'; c <= 'z'; c++) {
            for (int i = 0; i < word.length(); i++) {
            	// 如果不相等，就尝试替换
                if (c != word.charAt(i)) {
                	// 得到替换完后的字符串
                    String nextWord = replace(word, i, c);
                    // 如果发现nextWord在dict里，说明nextWord可以是word的邻居，将其从dict里删去并加入nextWords列表里
                    if (dict.remove(nextWord)) {
                        nextWords.add(nextWord);
                    }
                }
            }
        }
        
        return nextWords;
    }
    
    private String replace(String s, int index, char c) {
        char[] chars = s.toCharArray();
        chars[index] = c;
        return new String(chars);
    }
}

空间复杂度$O(n+l)\approx O(n)$，图的节点数和字符串缓存之和；getNextWordsAndRemove这个函数的时间复杂度是$O(25l^2)$，因为每次replace和dict里删除nextWord的时候都需要$O(l)$的时间，所以总时间复杂度是$O(n25l^3)=O(n{l}^3)$。