Update test.go

Author: halfrost

.vscode/settings.json

@@ -8,7 +8,7 @@
         "editor.insertSpaces": false,
         "editor.formatOnSave": true,
         "editor.codeActionsOnSave": {
-            "source.organizeImports": true
+            "source.organizeImports": "explicit"
         }
     }
 }

coverage.txt

@@ -23,6 +23,11 @@ type ans215 struct {
 	one int
 }
 
+// clone215 复制切片，避免多个就地改写的解法共享同一底层数组。
+func clone215(a []int) []int {
+	return append([]int(nil), a...)
+}
+
 func Test_Problem215(t *testing.T) {
 
 	qs := []question215{
@@ -61,10 +66,19 @@ func Test_Problem215(t *testing.T) {
 	fmt.Printf("------------------------Leetcode Problem 215------------------------\n")
 
 	for _, q := range qs {
-		_, p := q.ans215, q.para215
-		fmt.Printf("【input】:%v    【output】:%v\n", p.one, findKthLargest(p.one, p.two))
-		findKthLargest1(p.one, p.two)
+		a, p := q.ans215, q.para215
+		// findKthLargest（快速选择）、findKthLargest1（排序）、getLeastNumbers 都会
+		// 就地改写传入切片，所以各给一份独立副本，互不污染。
+		got := findKthLargest(clone215(p.one), p.two)
+		got1 := findKthLargest1(clone215(p.one), p.two)
+		fmt.Printf("【input】:%v    【output】:%v\n", p.one, got)
+		if got != a.one || got1 != a.one {
+			t.Fatalf("input %v, k=%v: expected %v, got %v / %v", p.one, p.two, a.one, got, got1)
+		}
+		// getLeastNumbers 是扩展题（最小的 k 个数），返回前 k 小，校验长度即可。
+		if least := getLeastNumbers(clone215(p.one), p.two); len(least) != p.two {
+			t.Fatalf("getLeastNumbers(%v, %v) len = %v, want %v", p.one, p.two, len(least), p.two)
+		}
 	}
 	fmt.Printf("\n\n\n")
-	getLeastNumbers(p.one, p.two)
 }

leetcode/0215.Kth-Largest-Element-in-an-Array/215. Kth Largest Element in an Array_test.go

@@ -41,8 +41,12 @@ func findBottomLeftValueDFS(root *TreeNode, curHeight int, res, maxHeight *int)
 
 // 解法二 BFS
 func findBottomLeftValue1(root *TreeNode) int {
-	queue := []*TreeNode{root}
+	if root == nil {
+		return 0
+	}
+	res, queue := root.Val, []*TreeNode{root}
 	for len(queue) > 0 {
+		res = queue[0].Val // 每层第一个节点即该层最左节点，最后停留的就是底层最左值
 		next := []*TreeNode{}
 		for _, node := range queue {
 			if node.Left != nil {
@@ -52,10 +56,7 @@ func findBottomLeftValue1(root *TreeNode) int {
 				next = append(next, node.Right)
 			}
 		}
-		if len(next) == 0 {
-			return queue[0].Val
-		}
 		queue = next
 	}
-	return 0
+	return res
 }

leetcode/0513.Find-Bottom-Left-Tree-Value/513. Find Bottom Left Tree Value.go

@@ -52,11 +52,15 @@ func Test_Problem513(t *testing.T) {
 	fmt.Printf("------------------------Leetcode Problem 513------------------------\n")
 
 	for _, q := range qs {
-		_, p := q.ans513, q.para513
+		a, p := q.ans513, q.para513
 		fmt.Printf("【input】:%v      ", p)
 		root := structures.Ints2TreeNode(p.one)
-		fmt.Printf("【output】:%v      \n", findBottomLeftValue(root))
-		findBottomLeftValue1(root)
+		got := findBottomLeftValue(root)
+		fmt.Printf("【output】:%v      \n", got)
+		got1 := findBottomLeftValue1(root)
+		if got != a.one || got1 != a.one {
+			t.Fatalf("input %v: expected %v, DFS got %v, BFS got %v", p.one, a.one, got, got1)
+		}
 	}
 	fmt.Printf("\n\n\n")
 }

leetcode/0513.Find-Bottom-Left-Tree-Value/513. Find Bottom Left Tree Value_test.go

@@ -30,6 +30,9 @@ func max(a int, b int) int {
 
 // 解法二 优化辅助空间的 DP
 func maxProfit714_1(prices []int, fee int) int {
+	if len(prices) <= 1 {
+		return 0
+	}
 	sell, buy := 0, -prices[0]
 	for i := 1; i < len(prices); i++ {
 		sell = max(sell, buy+prices[i]-fee)

leetcode/0714.Best-Time-to-Buy-and-Sell-Stock-with-Transaction-Fee/714. Best Time to Buy and Sell Stock with Transaction Fee.go

@@ -51,9 +51,13 @@ func Test_Problem714(t *testing.T) {
 	fmt.Printf("------------------------Leetcode Problem 714------------------------\n")
 
 	for _, q := range qs {
-		_, p := q.ans714, q.para714
-		fmt.Printf("【input】:%v       【output】:%v\n", p, maxProfit714(p.one, p.f))
-		maxProfit714_1(p.one, p.f)
+		a, p := q.ans714, q.para714
+		got := maxProfit714(p.one, p.f)
+		fmt.Printf("【input】:%v       【output】:%v\n", p, got)
+		got1 := maxProfit714_1(p.one, p.f)
+		if got != a.one || got1 != a.one {
+			t.Fatalf("input %v, fee=%v: expected %v, got %v / %v", p.one, p.f, a.one, got, got1)
+		}
 	}
 	fmt.Printf("\n\n\n")
 }

leetcode/0714.Best-Time-to-Buy-and-Sell-Stock-with-Transaction-Fee/714. Best Time to Buy and Sell Stock with Transaction Fee_test.go

@@ -56,9 +56,16 @@ func Test_Problem719(t *testing.T) {
 	fmt.Printf("------------------------Leetcode Problem 719------------------------\n")
 
 	for _, q := range qs {
-		_, p := q.ans719, q.para719
-		fmt.Printf("【input】:%v       【output】:%v\n", p, smallestDistancePair(p.num, p.k))
+		a, p := q.ans719, q.para719
+		got := smallestDistancePair(p.num, p.k) // 会把 p.num 排序
+		fmt.Printf("【input】:%v       【output】:%v\n", p, got)
+		if got != a.one {
+			t.Fatalf("input %v, k=%v: expected %v, got %v", p.num, p.k, a.one, got)
+		}
+		// 双指针解法与暴力解法在已排序数组上对同一距离阈值的计数应当一致。
+		if c1, c2 := findDistanceCount(p.num, a.one), findDistanceCount1(p.num, a.one); c1 != c2 {
+			t.Fatalf("distance count mismatch for %v, num=%v: %v vs %v", p.num, a.one, c1, c2)
+		}
 	}
 	fmt.Printf("\n\n\n")
-	findDistanceCount1(p.num, p.k)
 }

leetcode/0719.Find-K-th-Smallest-Pair-Distance/719. Find K-th Smallest Pair Distance_test.go

@@ -65,14 +65,30 @@ func Test_Problem864(t *testing.T) {
 			para864{[]string{"@..aA", "..B#.", "....b"}},
 			ans864{6},
 		},
+
+		{
+			para864{[]string{}},
+			ans864{0},
+		},
 	}
 
 	fmt.Printf("------------------------Leetcode Problem 864------------------------\n")
 
 	for _, q := range qs {
-		_, p := q.ans864, q.para864
-		fmt.Printf("【input】:%v       【output】:%v\n", p, shortestPathAllKeys(p.one))
-		shortestPathAllKeys1(p.one)
+		a, p := q.ans864, q.para864
+		got := shortestPathAllKeys(p.one)
+		fmt.Printf("【input】:%v       【output】:%v\n", p, got)
+		if got != a.one {
+			t.Fatalf("input %v: expected %v, got %v", p.one, a.one, got)
+		}
+		// 解法二是指数级 DFS（剪枝不足，作者已注明会超时）。大网格（如第一个 10x10
+		// 用例）会跑到分钟级导致测试卡住，所以只在小网格上调用它来覆盖代码，
+		// 大网格只验证解法一。
+		if len(p.one) <= 5 {
+			if got1 := shortestPathAllKeys1(p.one); got1 != a.one {
+				t.Fatalf("input %v: expected %v, shortestPathAllKeys1 got %v", p.one, a.one, got1)
+			}
+		}
 	}
 	fmt.Printf("\n\n\n")
 }

leetcode/0864.Shortest-Path-to-Get-All-Keys/864. Shortest Path to Get All Keys_test.go

@@ -25,6 +25,11 @@ type ans1203 struct {
 	one []int
 }
 
+// clone1203 复制一份 group 切片，避免两个解法共享并就地改写同一底层数组。
+func clone1203(a []int) []int {
+	return append([]int(nil), a...)
+}
+
 func Test_Problem1203(t *testing.T) {
 
 	qs := []question1203{
@@ -38,14 +43,33 @@ func Test_Problem1203(t *testing.T) {
 			para1203{8, 2, []int{-1, -1, 1, 0, 0, 1, 0, -1}, [][]int{{}, {6}, {5}, {6}, {3}, {}, {4}, {}}},
 			ans1203{[]int{}},
 		},
+
+		// 祖先项目本身没有分组（group 为 -1），覆盖按 ancestor 自身作组的分支
+		{
+			para1203{3, 1, []int{-1, 0, 0}, [][]int{{}, {0}, {}}},
+			ans1203{[]int{0, 1, 2}},
+		},
+
+		// 组与组之间形成环，无法完成组间拓扑排序，返回空
+		{
+			para1203{2, 2, []int{0, 1}, [][]int{{1}, {0}}},
+			ans1203{[]int{}},
+		},
 	}
 
 	fmt.Printf("------------------------Leetcode Problem 1203------------------------\n")
 
 	for _, q := range qs {
-		_, p := q.ans1203, q.para1203
-		fmt.Printf("【input】:%v       【output】:%v\n", p, sortItems1(p.n, p.m, p.group, p.beforeItems))
-		sortItems(p.n, p.m, p.group, p.beforeItems)
+		a, p := q.ans1203, q.para1203
+		// sortItems1 会就地把 group 里的 -1 改写成 m+i，必须给每个解法各传一份
+		// group 的独立副本，否则第二个解法会读到被污染的 group 而数组越界 panic。
+		got1 := sortItems1(p.n, p.m, clone1203(p.group), p.beforeItems)
+		got := sortItems(p.n, p.m, clone1203(p.group), p.beforeItems)
+		fmt.Printf("【input】:%v       【output】:%v\n", p, got1)
+		// 拓扑排序的合法顺序不唯一，这里只校验长度：有解时长度为 n，无解时为空。
+		if len(got) != len(a.one) || len(got1) != len(a.one) {
+			t.Fatalf("input %v: expected len %v, sortItems got %v, sortItems1 got %v", p, len(a.one), got, got1)
+		}
 	}
 	fmt.Printf("\n\n\n")
 }