EXAMPLE
Input: DAMP, LIKE
Output: DAMP -> LAMP -> LIMP -> LIME -> LIKE

思路：

这其实就是广度优先遍历。遍历过程中，我们需要记录路径，在找到目标单词后，根据记录的路径打印出变形过程。

BFS的变形体。对起始单词的每一个字母都做替换，把替换后的单词加入到queue中，并同时维护一个Map来记录变化前单词和变化后单词的联系。用来回溯时能打印出路径。

[java] view plain copy

1. package Hard;
2. import java.util.HashSet;
3. import java.util.LinkedList;
4. import java.util.Map;
5. import java.util.Queue;
6. import java.util.Set;
7. import java.util.TreeMap;
8. import java.util.TreeSet;
9. /**
10. * Given two words of equal length that are in a dictionary,  write a method to  trans-
11. form  one word into another word by changing only one letter at a time. The new
12. word you get in each step must be in the dictionary.
13. 给定两个有着相同长度且都在字典内的单词，要求写一个方法来把一个单词变型成另一个单词。
14. 一次只能转换一个字母，且每次生成的单词必须在字典内
15. *
16. */
17. public class S18_10 {
18. public static LinkedList<String> transform(String startWord, String stopWord, Set<String> dictionary) {
19. startWord = startWord.toUpperCase();
20. stopWord = stopWord.toUpperCase();
21. Queue<String> actionQueue = new LinkedList<String>();
22. Set<String> visitedSet = new HashSet<String>();
23. Map<String, String> backtrackMap = new TreeMap<String, String>();
24. actionQueue.add(startWord);
25. visitedSet.add(startWord);
26. while (!actionQueue.isEmpty()) {
27. String w = actionQueue.poll();
28. // For each possible word v from w with one edit operation
29. for (String v : getOneEditWords(w)) {
30. if (v.equals(stopWord)) {       // Found our word! Now, back track.
31. LinkedList<String> list = new LinkedList<String>();
32. list.add(v);        // Append v to list
33. while (w != null) {
34. list.add(0, w);
35. w = backtrackMap.get(w);
36. }
37. return list;
38. }
39. // If v is a dictionary word
40. if (dictionary.contains(v)) {
41. if (!visitedSet.contains(v)) {
42. actionQueue.add(v);
43. visitedSet.add(v);          // mark visited
44. backtrackMap.put(v, w); // w is the previous state of v
45. }
46. }
47. }
48. }
49. return null;
50. }
51. // 改变word的某一个字母
52. private static Set<String> getOneEditWords(String word) {
53. Set<String> words = new TreeSet<String>();
54. for (int i = 0; i < word.length(); i++) {        // for every letter
55. char[] wordArray = word.toCharArray();
56. // change that letter to something else
57. for (char c = 'A'; c <= 'Z'; c++) {
58. if (c != word.charAt(i)) {
59. wordArray[i] = c;
60. words.add(new String(wordArray));
61. }
62. }
63. }
64. return words;
65. }
66. public static HashSet<String> setupDictionary(String[] words) {
67. HashSet<String> hash = new HashSet<String>();
68. for (String word : words) {
69. hash.add(word.toUpperCase());
70. }
71. return hash;
72. }
73. public static void main(String[] args) {
74. String[] words = { "maps", "tan", "tree", "apple", "cans", "help",
75. "aped", "free", "apes", "flat", "trap", "fret", "trip", "trie",
76. "frat", "fril" };
77. HashSet<String> dict = setupDictionary(words);
78. LinkedList<String> list = transform("tree", "flat", dict);
79. for (String word : list) {
80. System.out.println(word);
81. }
82. }
83. }