题目

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"
dict = ["hot","dot","dog","lot","log"]

Return

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

Note:

  • All words have the same length.
  • All words contain only lowercase alphabetic characters.

题解

答案是http://www.1point3acres.com/bbs/thread-51646-1-1.html 上面
iostreamin写的。

我就直接贴过来就好,这道题多读读代码看明白。

代码:

  1    public ArrayList<ArrayList<String>> findLadders(String start, String end, HashSet<String> dict) {  
  2           
  3         HashMap<String, HashSet<String>> neighbours = new HashMap<String, HashSet<String>>();  
  4           
  5         dict.add(start);  
  6         dict.add(end);  
  7           
  8         // init adjacent graph          
  9         for(String str : dict){  
 10             calcNeighbours(neighbours, str, dict);  
 11         }  
 12           
 13         ArrayList<ArrayList<String>> result = new ArrayList<ArrayList<String>>();  
 14           
 15         // BFS search queue  
 16         LinkedList<Node> queue = new LinkedList<Node>();  
 17         queue.add(new Node(null, start, 1)); //the root has not parent and its level == 1 
 18           
 19         // BFS level  
 20         int previousLevel = 0;  
 21           
 22         // mark which nodes have been visited, to break infinite loop  
 23         HashMap<String, Integer> visited = new HashMap<String, Integer>();   
 24         while(!queue.isEmpty()){  
 25             Node n = queue.pollFirst();              
 26             if(end.equals(n.str)){   
 27                 // fine one path, check its length, if longer than previous path it's valid  
 28                 // otherwise all possible short path have been found, should stop  
 29                 if(previousLevel == 0 || n.level == previousLevel){  
 30                     previousLevel = n.level;  
 31                     findPath(n, result);                      
 32                 }else {  
 33                     // all path with length *previousLevel* have been found  
 34                     break;  
 35                 }                  
 36             }else {  
 37                 HashSet<String> set = neighbours.get(n.str);                   
 38                   
 39                 if(set == null || set.isEmpty()) continue;  
 40                 // note: I'm not using simple for(String s: set) here. This is to avoid hashset's  
 41                 // current modification exception.  
 42                 ArrayList<String> toRemove = new ArrayList<String>();  
 43                 for (String s : set) {  
 44                       
 45                     // if s has been visited before at a smaller level, there is already a shorter   
 46                     // path from start to s thus we should ignore s so as to break infinite loop; if   
 47                     // on the same level, we still need to put it into queue.  
 48                     if(visited.containsKey(s)){  
 49                         Integer occurLevel = visited.get(s);  
 50                         if(n.level+1 > occurLevel){  
 51                             neighbours.get(s).remove(n.str);  
 52                             toRemove.add(s);  
 53                             continue;  
 54                         }  
 55                     }  
 56                     visited.put(s,  n.level+1);  
 57                     queue.add(new Node(n, s, n.level + 1));  
 58                     if(neighbours.containsKey(s))  
 59                         neighbours.get(s).remove(n.str);  
 60                 }  
 61                 for(String s: toRemove){  
 62                     set.remove(s);  
 63                 }  
 64             }  
 65         }  
 66   
 67         return result;  
 68     }  
 69       
 70     public void findPath(Node n, ArrayList<ArrayList<String>> result){  
 71         ArrayList<String> path = new ArrayList<String>();  
 72         Node p = n;  
 73         while(p != null){  
 74             path.add(0, p.str);  
 75             p = p.parent;   
 76         }  
 77         result.add(path);  
 78     }  
 79   
 80     /* 
 81      * complexity: O(26*str.length*dict.size)=O(L*N) 
 82      */  
 83     void calcNeighbours(HashMap<String, HashSet<String>> neighbours, String str, HashSet<String> dict) {  
 84         int length = str.length();  
 85         char [] chars = str.toCharArray();  
 86         for (int i = 0; i < length; i++) {  
 87               
 88             char old = chars[i];   
 89             for (char c = 'a'; c <= 'z'; c++) {  
 90   
 91                 if (c == old)  continue;  
 92                 chars[i] = c;  
 93                 String newstr = new String(chars);                  
 94                   
 95                 if (dict.contains(newstr)) {  
 96                     HashSet<String> set = neighbours.get(str);  
 97                     if (set != null) {  
 98                         set.add(newstr);  
 99                     } else {  
                         HashSet<String> newset = new HashSet<String>();  
                         newset.add(newstr);  
                         neighbours.put(str, newset);  
                     }  
                 }                  
             }  
             chars[i] = old;  
         }  
     }  
       
     private class Node {  
         public Node parent;  //previous node
         public String str;  
         public int level;  
         public Node(Node p, String s, int l){  
             parent = p;  
             str = s;  
             level = l;  
         }  
     } 
 Reference:http://www.1point3acres.com/bbs/thread-51646-1-1.html

Word Ladder II leetcode java的更多相关文章

  1. Word Break II leetcode java

    题目: Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where e ...

  2. Word Ladder II [leetcode]

    本题有几个注意点: 1. 回溯找路径时.依据路径的最大长度控制回溯深度 2. BFS时,在找到end单词后,给当前层做标记find=true,遍历完当前层后结束.不须要遍历下一层了. 3. 能够将字典 ...

  3. [leetcode]Word Ladder II @ Python

    [leetcode]Word Ladder II @ Python 原题地址:http://oj.leetcode.com/problems/word-ladder-ii/ 参考文献:http://b ...

  4. LeetCode: Word Ladder II 解题报告

    Word Ladder II Given two words (start and end), and a dictionary, find all shortest transformation s ...

  5. [Leetcode Week5]Word Ladder II

    Word Ladder II 题解 原创文章,拒绝转载 题目来源:https://leetcode.com/problems/word-ladder-ii/description/ Descripti ...

  6. 【leetcode】Word Ladder II

      Word Ladder II Given two words (start and end), and a dictionary, find all shortest transformation ...

  7. LeetCode :Word Ladder II My Solution

    Word Ladder II Total Accepted: 11755 Total Submissions: 102776My Submissions Given two words (start  ...

  8. leetcode 127. Word Ladder、126. Word Ladder II

    127. Word Ladder 这道题使用bfs来解决,每次将满足要求的变换单词加入队列中. wordSet用来记录当前词典中的单词,做一个单词变换生成一个新单词,都需要判断这个单词是否在词典中,不 ...

  9. 126. Word Ladder II(hard)

    126. Word Ladder II 题目 Given two words (beginWord and endWord), and a dictionary's word list, find a ...

随机推荐

  1. DPDK+OpenvSwitch-centos7.4安装

    系统版本 [root@controller ~]# cat /etc/redhat-release CentOS Linux release 7.4.1708 (Core) DPDK版本: dpdk- ...

  2. HTTP协议-缓存

    HTTP 协议中,缓存更多关心的文档资源的再利用.其目的是减少数据传输,加快相应速度等等.而对于缓存采用的是什么方案,也就是存在内存中还是硬盘中之类的问题,就属于另外的内容了. 假设,我身在广东,但是 ...

  3. codevs 2821 天使之城

    题目描述 Description 天使城有一个火车站,每辆火车都从A方向驶入车站,再从B方向驶出车站. 为了调度火车,火车站设有停放轨道,可存放5辆火车.已知从A进入车站顺序为1.2.3…….现在给你 ...

  4. 8.9 正睿暑期集训营 Day6

    目录 2018.8.9 正睿暑期集训营 Day6 A 萌新拆塔(状压DP) B 奇迹暖暖 C 风花雪月(DP) 考试代码 A B C 2018.8.9 正睿暑期集训营 Day6 时间:2.5h(实际) ...

  5. C++最快的读取文件的方案(scanf,cin(及取消sync),fread)的详细对比

    竞赛中,遇到大数据时,往往读文件成了程序运行速度的瓶颈,需要更快的读取方式.相信几乎所有的C++学习者都在cin机器缓慢的速度上栽过跟头,于是从此以后发誓不用cin读数据.还有人说Pascal的rea ...

  6. Ubuntu 16.04实现SSH无密码登录/免密登录/自动登录(ssh-keygen/ssh-copy-id)

    ssh-keygen:产生公钥与私钥(在~/.ssh) ssh-copy-id:将本机的公钥复制到远程机器的authorized_keys文件中(在~/.ssh),ssh-copy-id也能让你有到远 ...

  7. Versaloon -- Connect To Targets

    Versaloon Full open-source(GPLv3) platform for multiple applications, including programmer, debugger ...

  8. mozilla/rr 调试

    http://rr-project.org/ https://github.com/mozilla/rr

  9. ADO.NET理论+实践

    题记: 每一事物的产生和存在都有其特定的理由.  理论:ADO.NET是一组与数据源进行交互的面向对象类库.通常情况下数据源就是数据库,当然同样也能是文本文件,Excel表格或XML文件,我们知道的数 ...

  10. 一个例子来看C#泛型是如何登场的

    有这样一个有关汽车的类. public class Car { public int ID { get; set; } public string Make { get; set; } } 现在,在客 ...