update

easy/141.js

@@ -43,7 +43,7 @@ function __main__() {
     n23.next = n2
     n2.next = n22
     n22.next = n23
-    /*eslint no-console: ["error", { allow: ["log"] }] */    
+    /*eslint no-console: ["error", { allow: ["log"] }] */
     console.log(hasCycle(n1))
     console.log(hasCycle(n2))
 }

medium/130.go

@@ -4,11 +4,11 @@ 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)
-}
+// func main() {
+// 	b1 := [][]byte{
+// 		{'X', 'X', 'X', 'X'},
+// 		{'X', 'O', 'O', 'X'},
+// 		{'X', 'O', 'X', 'X'},
+// 		{'X', 'X', 'O', 'X'}}
+// 	solve(b1)
+// }

medium/131.go

@@ -0,0 +1,39 @@
+package main
+
+func partition(s string) [][]string {
+	length := len(s)
+	lists := [][]string{}
+	list := []string{}
+	partitionHelper(&lists, &list, s, 0, length)
+	return lists
+}
+
+// Backtracking algorithm, try to understand & remember
+func partitionHelper(lists *[][]string, list *[]string, s string, beg, end int) {
+	if beg == end {
+		newList := make([]string, len(*list))
+		copy(newList, *list)
+		*lists = append(*lists, newList)
+		return
+	}
+	for i := beg + 1; i <= end; i++ {
+		if isPalindrome(s, beg, i) {
+			*list = append(*list, s[beg:i])
+			partitionHelper(lists, list, s, i, end)
+			*list = (*list)[:len(*list)-1] // Backtrack
+		}
+	}
+}
+
+func isPalindrome(s string, beg, end int) bool {
+	for ; beg < end-1; beg, end = beg+1, end-1 {
+		if s[beg] != s[end-1] {
+			return false
+		}
+	}
+	return true
+}
+
+// func main() {
+// 	fmt.Println(partition("aabbb"))
+// }

medium/133.js

@@ -0,0 +1,57 @@
+'use strict'
+
+/**
+ * Definition for undirected graph.
+ * function UndirectedGraphNode(label) {
+ *     this.label = label;
+ *     this.neighbors = [];   // Array of UndirectedGraphNode
+ * }
+ */
+
+
+function UndirectedGraphNode(label) {
+    this.label = label
+    this.neighbors = [] // Array of UndirectedGraphNode
+}
+
+/**
+ * @param {UndirectedGraphNode} graph
+ * @return {UndirectedGraphNode}
+ */
+var cloneGraph = function (graph) {
+    if (graph == null) return null
+    const map = new Map()
+    return clone(graph, map)
+}
+
+/**
+ * @param {UndirectedGraphNode} node 
+ * @param {Map} map
+ * @return {UndirectedGraphNode}
+ */
+function clone(node, map) { // DFS
+    if (node === null) return null
+    if (map.get(node.label) !== undefined)
+        return map.get(node.label)
+    const copy = new UndirectedGraphNode(node.label)
+    map.set(copy.label, copy)
+    for (const n of node.neighbors) {
+        copy.neighbors.push(clone(n, map))
+    }
+    return copy
+}
+
+function __main__() {
+    /* eslint no-console: ["error", {allow: ["log"]}] */
+    const logger = console.log.bind(console)
+    const n3 = new UndirectedGraphNode(3)
+    const n2 = new UndirectedGraphNode(2)
+    const n1 = new UndirectedGraphNode(1)
+    n3.neighbors = [n2, n3]
+    n2.neighbors = [n1, n3]
+    n1.neighbors = [n2, n3]
+    const n = cloneGraph(n1)
+    logger(n)
+}
+
+__main__()

medium/134.go

@@ -0,0 +1,9 @@
+package main
+
+func canCompleteCircuit(gas []int, cost []int) int {
+	return -1
+}
+
+func main() {
+
+}

medium/86.go

@@ -23,33 +23,33 @@ package main
  *     Next *ListNode
  * }
  */
-func partition(head *ListNode, x int) *ListNode {
-	if head == nil || head.Next == nil {
-		return head
-	}
-	dummy := ListNode{0, head}
-	fast, slow := &dummy, &dummy
-	// slow -> body -> fast -> target -> tail
-	// => slow -> target -> body -> fast -> tail
-	// => slow -> body -> fast -> tail
-	// or fast/slow -> tail
-	for fast != nil {
-		if fast.Next != nil && fast.Next.Val < x {
-			if fast == slow {
-				fast = fast.Next
-			} else {
-				tail := fast.Next.Next
-				fast.Next.Next = slow.Next
-				slow.Next = fast.Next
-				fast.Next = tail
-			}
-			slow = slow.Next
-		} else {
-			fast = fast.Next
-		}
-	}
-	return dummy.Next
-}
+// func partition(head *ListNode, x int) *ListNode {
+// 	if head == nil || head.Next == nil {
+// 		return head
+// 	}
+// 	dummy := ListNode{0, head}
+// 	fast, slow := &dummy, &dummy
+// 	// slow -> body -> fast -> target -> tail
+// 	// => slow -> target -> body -> fast -> tail
+// 	// => slow -> body -> fast -> tail
+// 	// or fast/slow -> tail
+// 	for fast != nil {
+// 		if fast.Next != nil && fast.Next.Val < x {
+// 			if fast == slow {
+// 				fast = fast.Next
+// 			} else {
+// 				tail := fast.Next.Next
+// 				fast.Next.Next = slow.Next
+// 				slow.Next = fast.Next
+// 				fast.Next = tail
+// 			}
+// 			slow = slow.Next
+// 		} else {
+// 			fast = fast.Next
+// 		}
+// 	}
+// 	return dummy.Next
+// }
 
 /* func main() {
 	l15 := ListNode{5, nil}