Word Ladder I & II

Word Ladder I

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the dictionary

Notice

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

Example

Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

As one shortest transformation is"hit" -> "hot" -> "dot" -> "dog" -> "cog", return its length 5.

分析：

BFS。但是下面这种发现现在通不过了，所以得想其它方法

 public class Solution {

     public int ladderLength(String start, String end, Set<String> dict) {
         if (diff(start, end) == ) return ;
         if (diff(start, end) == ) return ;

         ArrayList<String> inner = new ArrayList<String>();
         ArrayList<String> outer = new ArrayList<String>();
         inner.add(start);
         int counter = ;
         while (inner.size() != ) {
             counter++;
             if (dict.size() == ) return ;
             for (int i = ; i < inner.size(); i++) {
                 ArrayList<String> dicts = new ArrayList<String>(dict);
                 for (int j = ; j < dicts.size(); j++) {
                     if (diff(inner.get(i), dicts.get(j)) == ) {
                         outer.add(dicts.get(j));
                         dict.remove(dicts.get(j));
                     }
                 }
             }

             for (int k = ; k < outer.size(); k++) {
                 if (diff(outer.get(k), end) <= ) {
                     return counter + ;
                 }
             }

             ArrayList<String> temp = inner;
             inner = outer;
             outer = temp;
             outer.clear();
         }
         return ;
     }

     private int diff(String start, String end) {
         int total = ;
         for (int i = ; i < start.length(); i++) {
             if (start.charAt(i) != end.charAt(i)) {
                 total++;
             }
         }
         return total;
     }
 }

第二种方法：递归，复杂度更高。

 public class Solution {
     public static void main(String[] args) {
         Set<String> set = new HashSet<String>();
         set.add("hot");
         set.add("dot");
         set.add("dog");
         set.add("lot");
         set.add("log");

         Solution s = new Solution();
         System.out.println(s.ladderLength("hit", "cog", set));
     }

     public List<List<String>> ladderLength(String begin, String end, Set<String> set) {

         List<String> list = new ArrayList<String>();
         List<List<String>> listAll = new ArrayList<List<String>>();
         Set<String> used = new HashSet<String>();
         helper(begin, end, list, listAll, used, set);
         return listAll;
     }

     // find out all possible solutions
     public void helper(String current, String end, List<String> list, List<List<String>> listAll, Set<String> used,
             Set<String> set) {
         list.add(current);
         used.add(current);

         if (diff(current, end) == ) {
             ArrayList<String> temp = new ArrayList<String>(list);
             temp.add(end);
             listAll.add(temp);
         }

         for (String str : set) {
             if (!used.contains(str) && diff(current, str) == ) {
                 helper(str, end, list, listAll, used, set);
             }
         }
         list.remove(current);
         used.remove(current);
     }

     // return the # of letters difference
     public int diff(String word1, String word2) {

         int count = ;
         for (int i = ; i < word1.length(); i++) {
             if (word1.charAt(i) != word2.charAt(i)) {
                 count++;
             }
         }
         return count;
     }
 }

方法3

 class Solution {
     public int ladderLength(String begin, String end, List<String> list) {
         Set<String> set = new HashSet<>(list);
         if (!set.contains(end)) return ;
         Queue<String> queue = new LinkedList<>();
         int level = ;
         queue.add(begin);
         while (queue.size() != ) {
             level++;
             int size = queue.size();
             for (int k = ; k <= size; k++) {
                 String word = queue.poll();
                 char[] chs = word.toCharArray();
                 for (int i = ; i < chs.length; i++) {
                     char ch = chs[i];
                     for (char temp = 'a'; temp <= 'z'; temp++) {
                         chs[i] = temp;
                         String tempStr = new String(chs);
                         if (tempStr.equals(end)) return level + ;
                         if (set.contains(tempStr)) {
                             set.remove(tempStr);
                             queue.offer(tempStr);
                         }
                     }
                     chs[i] = ch;
                 }
             }
         }
         return ;
     }
 }

Word Ladder II

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that: 1) Only one letter can be changed at a time, 2) Each intermediate word must exist in the dictionary.

For example, given: start = "hit", end = "cog", and dict = ["hot","dot","dog","lot","log"], return:

  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

分析：

原理同上，按照层进行递进，当最外层到达end以后，我们就退出。

 class Solution {
     public List<List<String>> findLadders(String start, String end, List<String> dictList) {
         List<List<String>> result = new ArrayList<>();
         boolean hasFound = false;
         Set<String> dict = new HashSet<>(dictList);
         Set<String> visited = new HashSet<>();
         if (!dict.contains(end)) {
             return result;
         }
         Queue<Node> candidates = new LinkedList<>();
         candidates.offer(new Node(start, null));
         while (!candidates.isEmpty()) {
             int count = candidates.size();
             if (hasFound) return result;
             for (int k = ; k <= count; k++) {
                 Node node = candidates.poll();
                 String word = node.word;
                 char[] chs = word.toCharArray();
                 for (int i = ; i < chs.length; i++) {
                     char temp = chs[i];
                     for (char ch = 'a'; ch <= 'z'; ch++) {
                         chs[i] = ch;
                         String newStr = new String(chs);
                         if (dict.contains(newStr)) {
                             visited.add(newStr);
                             Node newNode = new Node(newStr, node);
                             candidates.add(newNode);
                             if (newStr.equals(end)) {
                                 hasFound = true;
                                 List<String> path = getPath(newNode);
                                 result.add(path);
                             }
                         }
                     }
                     chs[i] = temp;
                 }
             }
             dict.removeAll(visited);
         }
         return result;
     }

     private List<String> getPath(Node node) {
         List<String> list = new LinkedList<>();
         while (node != null) {
             list.add(, node.word);
             node = node.pre;
         }
         return list;
     }
 }

 class Node {
     String word;
     Node pre;

     public Node(String word, Node pre) {
         this.word = word;
         this.pre = pre;
     }
 }