[Function add]

1. Add some leetcode solutions.

Author: Seanforfun

README.md

@@ -229,6 +229,22 @@
 
 [120. Triangle](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/120.%20Triangle.md)
 
+[121. Best Time to Buy and Sell Stock](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/121.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock.md)
+
+[122. Best Time to Buy and Sell Stock II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/122.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.md)
+
+[123. Best Time to Buy and Sell Stock III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/123.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock%20III.md)
+
+[124. Binary Tree Maximum Path Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/124.%20Binary%20Tree%20Maximum%20Path%20Sum.md)
+
+[125. Valid Palindrome](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/125.%20Valid%20Palindrome.md)
+
+[127. Word Ladder](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/127.%20Word%20Ladder.md)
+
+[128. Longest Consecutive Sequence](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/128.%20Longest%20Consecutive%20Sequence.md)
+
+[129. Sum Root to Leaf Numbers](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/129.%20Sum%20Root%20to%20Leaf%20Numbers.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/127. Word Ladder.md

@@ -1,4 +1,40 @@
 ## 127. Word Ladder
+### Question:
+Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:
+1. Only one letter can be changed at a time.
+2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
+
+Note:
+* Return 0 if there is no such transformation sequence.
+* All words have the same length.
+* All words contain only lowercase alphabetic characters.
+* You may assume no duplicates in the word list.
+* You may assume beginWord and endWord are non-empty and are not the same.
+
+```
+Example 1:
+
+Input:
+beginWord = "hit",
+endWord = "cog",
+wordList = ["hot","dot","dog","lot","log","cog"]
+
+Output: 5
+
+Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
+return its length 5.
+
+Example 2:
+
+Input:
+beginWord = "hit"
+endWord = "cog"
+wordList = ["hot","dot","dog","lot","log"]
+
+Output: 0
+```
+Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
+
 ### Thinking:
 * Method1:
 	* 通过递归实现， 无法AC
@@ -80,4 +116,42 @@ class Solution {
         return 0;
     }
 }
-```
+```
+
+### 二刷
+1. 一刷的时候没有写出来这道题目，尝试了bfs但是无法AC。
+2. 二刷的时候参考了[LeetCode 127. Word Ladder](https://www.jianshu.com/p/753bd585d57e), 实际上这就是一道最短路径的题目。
+```Java
+class Solution {
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+        if(beginWord == null || endWord == null) return 0;
+        Set<String> wordSet = new HashSet<>(wordList);
+        Set<String> visited = new HashSet<>();
+        visited.add(beginWord);
+        int res = 1;
+        while(!visited.contains(endWord)){
+            Set<String> temp = new HashSet<>();
+            for(String s : visited){
+                for(int i = 0; i < s.length(); i++){
+                    char[] arr = s.toCharArray();
+                    for(char c = 'a'; c <= 'z'; c++){
+                        arr[i] = c;
+                        String newWord = new String(arr);
+                        if(wordSet.contains(newWord)){
+                            temp.add(newWord);
+                            wordSet.remove(newWord);
+                        }
+                    }
+                }
+            }
+            if(temp.size() == 0) return 0;
+            res ++;
+            visited = temp;
+        }
+        return res;
+    }
+}
+```
+
+### Reference
+1. [LeetCode 127. Word Ladder](https://www.jianshu.com/p/753bd585d57e)

leetcode/128. Longest Consecutive Sequence.md

@@ -65,4 +65,27 @@ class Solution {
         return max;
     }
 }
+```
+
+### 二刷
+其实用Set就可以解决问题，最重要的是，要判断前面的那一位数字并不存在，减少了很多无谓的判断。
+```Java
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if(nums == null || nums.length == 0) return 0;
+        Set<Integer> set = new HashSet<>();
+        for(int n : nums) set.add(n);
+        int result = 0;
+        for(int i = 0; i < nums.length; i++){
+            int res = 1;
+            if(!set.contains(nums[i] - 1)){
+                while(set.contains(++nums[i])){
+                    res++;
+                }
+            }
+            result = Math.max(res, result);
+        }
+        return result;
+    }
+}
 ```

leetcode/129. Sum Root to Leaf Numbers.md

@@ -73,4 +73,37 @@ class Solution {
             dfs(root.right, sum, result);
     }
 }
+```
+
+### 二刷
+典型的dfs，深度优先。
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int sumNumbers(TreeNode root) {
+        if(root == null) return 0;
+        List<Integer> temp = new LinkedList<>();
+        dfs(root, temp, 0);
+        int result = 0;
+        for(Integer s : temp) result += s;
+        return result;
+    }
+    private void dfs(TreeNode node, List<Integer> sum, int cur){
+        cur = cur * 10 + node.val;
+        if(node.left == null && node.right == null)
+            sum.add(cur);
+        else{
+            if(node.left != null) dfs(node.left, sum, cur);
+            if(node.right != null) dfs(node.right, sum, cur);
+        }
+    }
+}
 ```