Merge pull request #203 from 0xff-dev/master

Add solution and test-cases for problem 915

Author: Cori1109

leetcode/1001-1100/1008.Construct-Binary-Search-Tree-from-Preorder-Traversal/1266.png

@@ -1,26 +1,29 @@
 # [1008.Construct Binary Search Tree from Preorder Traversal][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
 
 ## Description
+Given an array of integers preorder, which represents the **preorder traversal** of a BST (i.e., **binary search tree**), construct the tree and return its root.
+
+It is **guaranteed** that there is always possible to find a binary search tree with the given requirements for the given test cases.
+
+A **binary search tree** is a binary tree where for every node, any descendant of `Node.left` has a value strictly less than `Node.val`, and any descendant of `Node.right` has a value **strictly greater** than `Node.val`.
+
+A **preorder traversal** of a binary tree displays the value of the node first, then traverses `Node.left`, then traverses `Node.right`.  
+<br>
 
 **Example 1:**
 
+![tree](./1266.png)
 ```
-Input: a = "11", b = "1"
-Output: "100"
+Input: preorder = [8,5,1,7,10,12]
+Output: [8,5,10,1,7,null,12]
 ```
 
-## 题意
-> ...
+**Example 2:**
 
-## 题解
-
-### 思路1
-> ...
-Construct Binary Search Tree from Preorder Traversal
-```go
+```
+Input: preorder = [1,3]
+Output: [1,null,3]
 ```
 
 

leetcode/1001-1100/1008.Construct-Binary-Search-Tree-from-Preorder-Traversal/README.md

@@ -1,5 +1,29 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(preorder []int) *TreeNode {
+	return buildBstFromPreOrder(preorder)
+}
+
+func buildBstFromPreOrder(pre []int) *TreeNode {
+	if len(pre) == 0 {
+		return nil
+	}
+
+	v := pre[0]
+	node := &TreeNode{Val: v}
+	idx := 1
+	for ; idx < len(pre); idx++ {
+		if pre[idx] > v {
+			break
+		}
+	}
+	if idx > 1 {
+		node.Left = buildBstFromPreOrder(pre[1:idx])
+	}
+
+	if idx < len(pre) {
+		node.Right = buildBstFromPreOrder(pre[idx:])
+	}
+
+	return node
 }

leetcode/1001-1100/1008.Construct-Binary-Search-Tree-from-Preorder-Traversal/Solution.go

@@ -10,12 +10,24 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs []int
+		expect *TreeNode
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", []int{1}, &TreeNode{Val: 1}},
+		{"TestCase2", []int{8, 9, 10}, &TreeNode{Val: 8, Right: &TreeNode{Val: 9, Right: &TreeNode{Val: 10}}}},
+		{"TestCase3", []int{10, 9, 8}, &TreeNode{Val: 10, Left: &TreeNode{Val: 9, Left: &TreeNode{Val: 8}}}},
+		{"TestCase4", []int{8, 5, 1, 7, 10, 12}, &TreeNode{
+			Val: 8,
+			Left: &TreeNode{
+				Val:   5,
+				Left:  &TreeNode{Val: 1},
+				Right: &TreeNode{Val: 7},
+			},
+			Right: &TreeNode{
+				Val:   10,
+				Right: &TreeNode{Val: 12},
+			},
+		}},
 	}
 
 	//	开始测试

leetcode/1001-1100/1008.Construct-Binary-Search-Tree-from-Preorder-Traversal/Solution_test.go

@@ -0,0 +1,7 @@
+package Solution
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}

leetcode/1001-1100/1008.Construct-Binary-Search-Tree-from-Preorder-Traversal/type.go

@@ -1,5 +1,19 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(nums []int) *TreeNode {
+	if len(nums) == 0 {
+		return nil
+	}
+
+	node := &TreeNode{}
+	mid := len(nums) / 2
+	node.Val = nums[mid]
+	if mid > 0 {
+		node.Left = Solution(nums[:mid])
+	}
+	if mid < len(nums)-1 {
+		node.Right = Solution(nums[mid+1:])
+	}
+
+	return node
 }

leetcode/101-200/0108.Convert-Sorted-Array-to-Binary-Search-Tree/Solution.go

@@ -10,12 +10,22 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs []int
+		expect *TreeNode
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", []int{-10, -3, 0, 5, 9}, &TreeNode{
+			Val: 0,
+			Left: &TreeNode{
+				Val:  -3,
+				Left: &TreeNode{Val: -10},
+			},
+			Right: &TreeNode{
+				Val:  9,
+				Left: &TreeNode{Val: 5},
+			},
+		}},
+		{"TestCase2", []int{1, 3}, &TreeNode{Val: 3, Left: &TreeNode{Val: 1}, Right: nil}},
+		{"TestCase3", []int{1}, &TreeNode{Val: 1}},
 	}
 
 	//	开始测试

leetcode/101-200/0108.Convert-Sorted-Array-to-Binary-Search-Tree/Solution_test.go

@@ -0,0 +1,7 @@
+package Solution
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}

leetcode/101-200/0108.Convert-Sorted-Array-to-Binary-Search-Tree/type.go

@@ -1,5 +1,73 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+import "fmt"
+
+func Solution(points [][]int) int {
+	if len(points) == 1 {
+		return 1
+	}
+	_max := 0
+	for idx := 1; idx < len(points); idx++ {
+		tmpSlopes := make(map[string]int)
+		tmpMax := 0
+		double := 0
+		for inner := 0; inner < idx; inner++ {
+			x1, y1, x2, y2 := points[inner][0], points[inner][1], points[idx][0], points[idx][1]
+			if x1 == x2 && y1 == y2 {
+				double++
+				continue
+			}
+			k := slope(x1, y1, x2, y2)
+			if _, ok := tmpSlopes[k]; !ok {
+				tmpSlopes[k] = 1
+			}
+			tmpSlopes[k]++
+			if tmpSlopes[k] > _max {
+				_max = tmpSlopes[k]
+			}
+		}
+
+		if tmpMax == 0 {
+			tmpMax = 1
+		}
+		tmpMax += double
+		if tmpMax > _max {
+			_max = tmpMax
+		}
+	}
+	return _max
+}
+
+func slope(x1, y1, x2, y2 int) string {
+	xx := x2 - x1
+	yy := y2 - y1
+	if xx == 0 {
+		return fmt.Sprintf("%d", x1)
+	}
+	if yy == 0 {
+		return fmt.Sprintf("%d", y1)
+	}
+	flag := xx*yy < 0
+	if xx < 0 {
+		xx = -xx
+	}
+	if yy < 0 {
+		yy = -yy
+	}
+	k := gcd(xx, yy)
+	yy /= k
+	xx /= k
+	s := fmt.Sprintf("%d/%d", yy, xx)
+	if flag {
+		return "-" + s
+	}
+	return s
+}
+
+// 斜率问题，考虑午饭整除的情况
+func gcd(x, y int) int {
+	if y == 0 {
+		return x
+	}
+	return gcd(y, x%y)
 }

leetcode/101-200/0149.Max-Points-on-a-Line/Solution.go

@@ -10,12 +10,12 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs [][]int
+		expect int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", [][]int{{1, 1}, {3, 2}, {5, 3}, {4, 1}, {2, 3}, {1, 4}}, 4},
+		{"TestCase2", [][]int{{1, 1}, {2, 2}, {3, 3}}, 3},
+		{"TestCase3", [][]int{{0, 0}, {4, 5}, {7, 8}, {8, 9}, {5, 6}, {3, 4}, {1, 1}}, 5},
 	}
 
 	//	开始测试

leetcode/101-200/0149.Max-Points-on-a-Line/Solution_test.go

@@ -1,28 +1,27 @@
 # [1104.Path In Zigzag Labelled Binary Tree][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+In an infinite binary tree where every node has two children, the nodes are labelled in row order.
+
+In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.
+
+![image](./tree.png)
+
+Given the `label` of a node in this tree, return the labels in the path from the root of the tree to the node with that `label`.
 
 **Example 1:**
 
 ```
-Input: a = "11", b = "1"
-Output: "100"
+Input: label = 14
+Output: [1,3,4,14]
 ```
 
-## 题意
-> ...
+__Example 2:__
 
-## 题解
-
-### 思路1
-> ...
-Path In Zigzag Labelled Binary Tree
-```go
 ```
-
+Input: label = 26
+Output: [1,2,6,10,26]
+```
 
 ## 结语
 

leetcode/1101-1200/1104.Path-In-Zigzag-Labelled-Binary-Tree/README.md

@@ -1,5 +1,26 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(label int) []int {
+	res := make([]int, 0)
+	idx, base := 0, 1
+	for ; base <= label; base, idx = base*2, idx+1 {
+	}
+
+	base, idx = base/2, idx-1
+	for {
+		nextBase, nextIdx := base/2, idx-1
+		res = append(res, label)
+		if nextIdx < 0 {
+			break
+		}
+		diff := (label - base) / 2
+		label = base - 1 - diff
+		base, idx = nextBase, nextIdx
+	}
+
+	for s, e := 0, len(res)-1; s < e; s, e = s+1, e-1 {
+		res[s], res[e] = res[e], res[s]
+	}
+
+	return res
 }

leetcode/1101-1200/1104.Path-In-Zigzag-Labelled-Binary-Tree/Solution.go

@@ -10,12 +10,13 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs int
+		expect []int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", 1, []int{1}},
+		{"TestCase2", 14, []int{1, 3, 4, 14}},
+		{"TestCase3", 26, []int{1, 2, 6, 10, 26}},
+		{"TestCase4", 1234, []int{1, 3, 4, 14, 19, 57, 77, 229, 308, 918, 1234}},
 	}
 
 	//	开始测试