update

.eslintrc.json

@@ -11,7 +11,7 @@
         ],
         "linebreak-style": [
             "error",
-            "windows"
+            "unix"
         ],
         "quotes": [
             "error",

medium/114.go

@@ -14,7 +14,7 @@ func flatten(root *TreeNode) { // Inorder flatten
 }
 
 // Reverse order of the inorder traversal
-// root -> left -> right to right -> left -> root
+// root -> left -> right => right -> left -> root
 func flattenHelper(root *TreeNode, prev **TreeNode) {
 	if root == nil {
 		return
@@ -26,9 +26,9 @@ func flattenHelper(root *TreeNode, prev **TreeNode) {
 	*prev = root
 }
 
-func main() {
-	root1 := sortedArrayToBST([]int{3, 2, 4, 1, 6, 5, 7})
-	printTree(root1)
-	flatten(root1)
-	printTree(root1)
-}
+// func main() {
+// 	root1 := sortedArrayToBST([]int{3, 2, 4, 1, 6, 5, 7})
+// 	printTree(root1)
+// 	flatten(root1)
+// 	printTree(root1)
+// }

medium/116.js

@@ -1,3 +1,5 @@
+'use strict'
+
 /**
  * Definition for binary tree with next pointer.
  * function TreeLinkNode(val) {
@@ -11,16 +13,88 @@ function TreeLinkNode(val) {
     this.left = this.right = this.next = null
 }
 
+
 /**
  * @param {TreeLinkNode} root
  * @return {void} Do not return anything, modify tree in-place instead.
  */
+// var connect = function (root) {
+//     if (root === null) {
+//         return
+//     }
+//     let curr = root
+//     let prev = null
+//     let queue = []
+//     queue.push({
+//         node: curr,
+//         level: 1
+//     })
+//     while (queue.length !== 0) {
+//         let q = queue[0]
+//         queue = queue.slice(1)
+//         if (prev !== null && prev.level === q.level) {
+//             prev.node.next = q.node
+//         }
+//         prev = q
+//         if (q.node.left !== null) {
+//             queue.push({
+//                 node: q.node.left,
+//                 level: q.level + 1
+//             })
+//         }
+//         if (q.node.right !== null) {
+//             queue.push({
+//                 node: q.node.right,
+//                 level: q.level + 1
+//             })
+//         }
+//     }
+// }
+
+// It is a FULL BST, so we can use some tricky method
 var connect = function(root) {
-    
+    if (root === null) return
+    connectHelper(root.left, root.right)
+    connectHelper(root.right, null)
+}
+
+function connectHelper(node, next) {
+    if (node === null) return
+    node.next = next
+    // NOTE: All values are truthy unless they are defined as falsy
+    // If next === null, && return false, false || null => null;
+    // else && return next.left, next.left || null => next.left
+    let nextRight = next && next.left || null
+    connectHelper(node.left, node.right)
+    connectHelper(node.right, nextRight)
 }
 
 function __main__() {
-    
+    /*eslint no-console: ["error", { allow: ["log"] }] */
+    let logger = console.log.bind(console)
+    //       1
+    //      / \
+    //     2   3
+    //    /\   /\
+    //   4  5 6  7
+    let n7 = new TreeLinkNode(7)
+    let n6 = new TreeLinkNode(6)
+    let n5 = new TreeLinkNode(5)
+    let n4 = new TreeLinkNode(4)
+    let n3 = new TreeLinkNode(3)
+    n3.left = n6
+    n3.right = n7
+    let n2 = new TreeLinkNode(2)
+    n2.left = n4
+    n2.right = n5
+    let n1 = new TreeLinkNode(1)
+    n1.left = n2
+    n1.right = n3
+    connect(n1)
+    logger(n1.next)
+    logger(n2.next)
+    logger(n4.next)
+    logger(n5.next)
 }
 
 __main__()

medium/117.js

@@ -0,0 +1,66 @@
+'use strict'
+
+/**
+ * Definition for binary tree with next pointer.
+ * function TreeLinkNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = this.next = null;
+ * }
+ */
+
+function TreeLinkNode(val) {
+    this.val = val
+    this.left = this.right = this.next = null
+}
+
+/**
+ * @param {TreeLinkNode} root
+ * @return {void} Do not return anything, modify tree in-place instead.
+ */
+var connect = function (root) {
+    // Important! Try to understand all tricks
+    while (root) {
+        let nextLevelPre = new TreeLinkNode()
+        let prev = nextLevelPre
+        while (root) {
+            if (root.left) {
+                prev.next = root.left // nextLevelPre is update here!
+                prev = root.left // Then prev moves on, left nextLevelPre unchanged
+            }
+            if (root.right) {
+                prev.next = root.right // The same
+                prev = root.right
+            }
+            root = root.next // Next root
+            // Just like:
+            //->2   3   4   --\    2 ->3   4
+            // / \ / \ / \  --/   / \ / \ / \
+        }
+        root = nextLevelPre.next // Next level
+    }
+}
+
+function __main__() {
+    /*eslint no-console: ["error", { allow: ["log"] }] */
+    let logger = console.log.bind(console)
+    //       1
+    //      / \
+    //     2   3
+    //    /    /\
+    //   4    6  7
+    let n7 = new TreeLinkNode(7)
+    let n6 = new TreeLinkNode(6)
+    let n4 = new TreeLinkNode(4)
+    let n3 = new TreeLinkNode(3)
+    n3.left = n6
+    n3.right = n7
+    let n2 = new TreeLinkNode(2)
+    n2.left = n4
+    let n1 = new TreeLinkNode(1)
+    n1.left = n2
+    n1.right = n3
+    connect(n1)
+    logger(n2)
+}
+
+__main__()

medium/120.go

@@ -0,0 +1,46 @@
+package main
+
+func minimumTotal(triangle [][]int) int {
+	length := len(triangle)
+	if length == 0 {
+		return 0
+	}
+	sum := make([]int, length)
+	sum[0] = triangle[0][0]
+	for i := 1; i < length; i++ { // Something like Dijkstra
+		// sum[] stores all minimum which take diff index as endpoint
+		former := sum[0]
+		sum[0] = former + triangle[i][0]
+		for j := 1; j < i; j++ {
+			tmp := sum[j]
+			if former < tmp {
+				sum[j] = former + triangle[i][j]
+			} else {
+				sum[j] = tmp + triangle[i][j]
+			}
+			former = tmp
+		}
+		sum[i] = former + triangle[i][i]
+	}
+	min := sum[0]
+	for i := 1; i < length; i++ {
+		if sum[i] < min {
+			min = sum[i]
+		}
+	}
+	return min
+}
+
+// func main() {
+// 	tri1 := [][]int{
+// 		{2},
+// 		{3, 4},
+// 		{6, 5, 7},
+// 		{4, 1, 8, 3}}
+// 	println(minimumTotal(tri1))
+// 	tri2 := [][]int{}
+// 	println(minimumTotal(tri2))
+// 	tri3 := [][]int{
+// 		{9}}
+// 	println(minimumTotal(tri3))
+// }

medium/127.go

@@ -0,0 +1,62 @@
+package main
+
+// begin & end are non-empty and not the same
+func ladderLength(beginWord string, endWord string, wordList []string) int {
+	wordCnt := len(wordList)
+	if wordCnt == 0 {
+		return 0
+	}
+	target := -1
+	for i := 0; i < wordCnt; i++ {
+		if wordList[i] == endWord {
+			target = i
+			break
+		}
+	}
+	if target == -1 {
+		return 0
+	}
+	newList := append(wordList, beginWord)
+	distance := make([]int, wordCnt+1)
+	distance[wordCnt] = 1 // Initial ladder length: 1
+	isMin := make([]bool, wordCnt+1)
+	queue := make([]int, 0)
+	queue = append(queue, wordCnt)
+	for len(queue) != 0 { // Dijkstra method
+		newQueue := make([]int, 0)
+		for len(queue) != 0 {
+			idx := queue[0]
+			queue = queue[1:] // Dequeue
+			for i := 0; i < wordCnt; i++ {
+				if !isMin[i] {
+					if isConvertible(newList[idx], newList[i]) &&
+						(distance[i] == 0 || distance[idx] < distance[i]) {
+						distance[i] = distance[idx] + 1
+					}
+					if len(queue) == 0 && distance[i] != 0 {
+						newQueue = append(newQueue, i)
+						isMin[i] = true
+					}
+				}
+			}
+		}
+		queue = newQueue
+	}
+	return distance[target]
+}
+
+func isConvertible(src, dst string) bool {
+	diff := 0
+	for i := 0; i < len(src); i++ {
+		if src[i] != dst[i] {
+			diff++
+		}
+	}
+	return diff == 1
+}
+
+// func main() {
+// 	wordList := []string{"hot", "dot", "dog", "lot", "log", "cog"}
+// 	println(ladderLength("dog", "but", wordList))
+// 	println(ladderLength("hit", "cog", wordList))
+// }

medium/129.go

@@ -0,0 +1,36 @@
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sumNumbers(root *TreeNode) int {
+	sum := 0
+	if root == nil {
+		return sum
+	}
+	sumNumbersHelper(root, 0, &sum)
+	return sum
+}
+
+func sumNumbersHelper(root *TreeNode, prefix int, sum *int) {
+	prefix = prefix*10 + root.Val
+	hasLeft, hasRight := root.Left != nil, root.Right != nil
+	if hasLeft {
+		sumNumbersHelper(root.Left, prefix, sum)
+	}
+	if hasRight {
+		sumNumbersHelper(root.Right, prefix, sum)
+	}
+	if !hasLeft && !hasRight {
+		*sum += prefix
+	}
+}
+
+// func main() {
+// 	println(sumNumbers(sortedArrayToBST([]int{1, 2, 3})))
+// }

medium/130.go

@@ -0,0 +1,14 @@
+package main
+
+func solve(board [][]byte) {
+
+}
+
+func main() {
+	b1 := [][]byte{
+		{'X', 'X', 'X', 'X'},
+		{'X', 'O', 'O', 'X'},
+		{'X', 'O', 'X', 'X'},
+		{'X', 'X', 'O', 'X'}}
+	solve(b1)
+}