給定兩個有着相同長度且都在字典內的單詞，要求寫一個方法來把一個單詞變型成另外一個單詞。 一次只能轉換一個字母，且每次生成的單詞必須在字典內

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

思路：

這其實就是廣度優先遍歷。遍歷過程當中，咱們須要記錄路徑，在找到目標單詞後，根據記錄的路徑打印出變形過程。

BFS的變形體。對起始單詞的每個字母都作替換，把替換後的單詞加入到queue中，並同時維護一個Map來記錄變化前單詞和變化後單詞的聯繫。用來回溯時能打印出路徑。

 

 

[java] view plain copy

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