word ladder2

Author: jiangyong07

src/main/java/joshua/leetcode/array/ProductOfArrayExceptSelf.java

@@ -59,4 +59,38 @@ public int[] productExceptSelf(int[] nums) {
             return fromLeft;
         }
     }
+
+    /**
+     * 方法2是方法1的一种巧妙的改进。
+     * 注意到方法1的两个list,fromLeft和fromRight可以合并。
+     * 在计算完fromLeft之后，实际上可以直接从fromLeft的尾部开始往左扫描，在计算result[k]的时候，
+     * fromLeft[0]用来存储nums[k+1,..,len-1]的乘积，在之前的计算中result[k]存储的是nums[0,...,k-1]的乘积，两者相乘就得到了最终结果。
+     * 同时可以将fromLeft[0]更新为fromLeft[0]*nums[k]
+     */
+    public static class Solution2 extends ProductOfArrayExceptSelf {
+
+        @Override
+        public int[] productExceptSelf(int[] nums) {
+            // i.e. [1,2,3,4]
+            int[] result = new int[nums.length];
+            for (int i = 0; i < nums.length; i++) {
+                if(i == 0) {
+                    result[0] = 1;
+                } else {
+                    result[i] = result[i-1] * nums[i-1];
+                }
+            }
+            /* result is now: [1, 1, 2, 6]
+             * the next iteration will be:
+             * [1,1,2,6] -> [1,1,2,6] -> [4,1,2,6]
+             * [4,1,2,6] -> [4,1,8,6] -> [12,1,8,6]
+             * [12,1,8,6] -> [12,12,8,6] -> [24,12,8,6]
+            */
+            for(int i = nums.length - 1; i > 0; i--) {
+                result[i] = result[i] * result[0];
+                result[0] *= nums[i];
+            }
+            return result;
+        }
+    }
 }

src/main/java/joshua/leetcode/bfs/WordLadder2.java

@@ -0,0 +1,125 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.bfs;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 126. Word Ladder II</br>
+ * <p/>
+ * <a href="https://leetcode.com/problems/word-ladder-ii/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class WordLadder2 {
+
+    /**
+     * Given two words (beginWord and endWord), and a dictionary's word list,
+     * find all shortest transformation sequence(s) from beginWord to endWord, such that:
+     * <p/>
+     * Only one letter can be changed at a time
+     * Each intermediate word must exist in the word list
+     * For example,
+     * <p/>
+     * Given:<br/>
+     * beginWord = "hit"
+     * endWord = "cog"
+     * wordList = ["hot","dot","dog","lot","log"]
+     * Return
+     * [
+     * ["hit","hot","dot","dog","cog"],
+     * ["hit","hot","lot","log","cog"]
+     * ]
+     * <br/>
+     * Note:<br/>
+     * <ul>
+     * <li>All words have the same length.</li>
+     * <li>All words contain only lowercase alphabetic characters./li>
+     * </ul>
+     *
+     * @param beginWord
+     * @param endWord
+     * @param wordList
+     * @return
+     */
+    public abstract List<List<String>> findLadders(String beginWord, String endWord, Set<String> wordList);
+
+    /**
+     *
+     */
+    public static class Solution1 extends WordLadder2 {
+
+        /**
+         * BFS算法，但是需要对每个节点保存已走过的路径。
+         *
+         * @param beginWord
+         * @param endWord
+         * @param wordList
+         * @return
+         */
+        @Override
+        public List<List<String>> findLadders(String beginWord, String endWord, Set<String> wordList) {
+            List<QueueItem> steps = new LinkedList<QueueItem>();
+            List<String> path = new ArrayList<String>();
+            path.add(beginWord);
+            steps.add(new QueueItem(beginWord, path));
+            List<List<String>> result = new ArrayList<List<String>>();
+            boolean found = false;
+            while (!steps.isEmpty()) {
+                List<QueueItem> newSteps = new LinkedList<QueueItem>();
+                for (int i = 0; i < steps.size(); i++) {
+                    QueueItem oldStep = steps.get(i);
+                    char[] chars = oldStep.word.toCharArray();
+                    boolean reached = false;
+                    for (int j = 0; j < chars.length; j++) {
+                        char ch = chars[j];
+                        for (int k = 0; k < 26; k++) {
+                            chars[j] = (char) (k + 'a');
+                            if (ch != chars[j]) {
+                                String str = new String(chars);
+                                if (str.equals(endWord)) {
+                                    found = reached = true;
+                                    oldStep.path.add(endWord);
+                                    result.add(oldStep.path);
+                                    break;
+                                }
+                                if (wordList.contains(str)) {
+                                    List<String> newPath = new ArrayList<String>(oldStep.path);
+                                    newPath.add(str);
+                                    newSteps.add(new QueueItem(str, newPath));
+                                }
+                            }
+                        }
+                        if (reached) {
+                            break;
+                        } else {
+                            chars[j] = ch;
+                        }
+                    }
+                }
+                if (found) {
+                    break;
+                } else {
+                    for (QueueItem item : newSteps) {
+                        wordList.remove(item.word);
+                    }
+                    steps = newSteps;
+                }
+            }
+            return result;
+        }
+
+        class QueueItem {
+            String word;
+            List<String> path;
+
+            public QueueItem(String word, List<String> path) {
+                this.word = word;
+                this.path = path;
+            }
+        }
+    }
+}

src/test/java/joshua/leetcode/bfs/WordLadder2Test.java

@@ -0,0 +1,24 @@
+package joshua.leetcode.bfs;
+
+import static org.junit.Assert.*;
+
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.google.common.collect.Sets;
+
+public class WordLadder2Test {
+
+    @Test
+    public void testSolution() {
+        String beginWord = "hit";
+        String endWord = "cog" ;
+        Set<String> wordList = Sets.newHashSet("hot","dot","dog","lot","log");
+        WordLadder2 solution = new WordLadder2.Solution1();
+        List<List<String>> result = solution.findLadders(beginWord, endWord, wordList);
+        System.out.println(result);
+    }
+
+}