Add solution 0611

Author: halfrost

leetcode/0611.Valid-Triangle-Number/611. Valid Triangle Number.go

@@ -0,0 +1,18 @@
+package leetcode
+
+import "sort"
+
+func triangleNumber(nums []int) int {
+	res := 0
+	sort.Ints(nums)
+	for i := 0; i < len(nums)-2; i++ {
+		k := i + 2
+		for j := i + 1; j < len(nums)-1 && nums[i] != 0; j++ {
+			for k < len(nums) && nums[i]+nums[j] > nums[k] {
+				k++
+			}
+			res += k - j - 1
+		}
+	}
+	return res
+}

leetcode/0611.Valid-Triangle-Number/611. Valid Triangle Number_test.go

@@ -0,0 +1,52 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question611 struct {
+	para611
+	ans611
+}
+
+// para 是参数
+// one 代表第一个参数
+type para611 struct {
+	nums []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans611 struct {
+	one int
+}
+
+func Test_Problem611(t *testing.T) {
+
+	qs := []question611{
+
+		{
+			para611{[]int{2, 2, 3, 4}},
+			ans611{3},
+		},
+
+		{
+			para611{[]int{4, 2, 3, 4}},
+			ans611{4},
+		},
+
+		{
+			para611{[]int{0, 0}},
+			ans611{0},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 611------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans611, q.para611
+		fmt.Printf("【input】:%v       【output】:%v\n", p, triangleNumber(p.nums))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0611.Valid-Triangle-Number/README.md

@@ -0,0 +1,37 @@
+# [611. Valid Triangle Number](https://leetcode.com/problems/valid-triangle-number/)
+
+## 题目
+
+Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.
+
+## 题目大意
+
+给定一个包含非负整数的数组，你的任务是统计其中可以组成三角形三条边的三元组个数。
+
+## 解题思路
+
+- 题意很简单，最容易想到的暴力解法是三重循环，暴力枚举，时间复杂度 O(n^3)。三重循环中最内层的循环可以优化，因为 k 和 i，j 存在关联性。第二层循环 j 从 i + 1 开始循环，k 从 j + 1 = i + 2 开始循环。循环累加 k 的值，直到 `nums[i] + nums[j] > nums[k]`，那么 `[nums[j + 1], nums[k - 1]]` 这个区间内的值都满足条件。满足条件的解个数增加 `k - j - 1` 个。j 再次递增 + 1，此时最内层的 k 不用从 j + 1 开始增加，只用从上次 k 开始增加即可。因为如果 `nums[i] + nums[j] > nums[k]`，如果这个 `nums[i] + nums[j + 1] > nums[m + 1]` 不等式成立，那么 m 一定不小于 k。所以内层循环 k 和 j 加起来的时间复杂度是 O(n)，最外层 i 的循环是 O(n)，这样优化以后，整体时间复杂度是 O(n^2)。
+- 可能有读者有疑问，三角形三条边的组成条件：任意两边之和大于第三边。`a + b > c`，`a + c > b`，`b + c > a`，此处为什么只判断了 `a + b > c` 呢？因为一开始进行了排序处理，使得 `a ≤ b ≤ c`，在这个前提下，`a + c > b`，`b + c > a` 是一定成立的。所以原问题便转化为只需关心 `a + b > c` 这一个不等式是否成立即可。此题的测试用例用有一种特殊情况，那就是其中一条边或者两条边长度为 0，那么 `a + b > c` 这个不等式一定不成立。综上，先排序预处理之后，只需要关心 `a + b > c` 这一个不等式是否成立即可。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func triangleNumber(nums []int) int {
+	res := 0
+	sort.Ints(nums)
+	for i := 0; i < len(nums)-2; i++ {
+		k := i + 2
+		for j := i + 1; j < len(nums)-1 && nums[i] != 0; j++ {
+			for k < len(nums) && nums[i]+nums[j] > nums[k] {
+				k++
+			}
+			res += k - j - 1
+		}
+	}
+	return res
+}
+```

website/content/ChapterFour/0600~0699/0609.Find-Duplicate-File-in-System.md

@@ -96,5 +96,5 @@ func findDuplicate(paths []string) [][]string {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0605.Can-Place-Flowers/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0617.Merge-Two-Binary-Trees/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0611.Valid-Triangle-Number/">下一页➡️</a></p>
 </div>

website/content/ChapterFour/0600~0699/0611.Valid-Triangle-Number.md

@@ -0,0 +1,44 @@
+# [611. Valid Triangle Number](https://leetcode.com/problems/valid-triangle-number/)
+
+## 题目
+
+Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.
+
+## 题目大意
+
+给定一个包含非负整数的数组，你的任务是统计其中可以组成三角形三条边的三元组个数。
+
+## 解题思路
+
+- 题意很简单，最容易想到的暴力解法是三重循环，暴力枚举，时间复杂度 O(n^3)。三重循环中最内层的循环可以优化，因为 k 和 i，j 存在关联性。第二层循环 j 从 i + 1 开始循环，k 从 j + 1 = i + 2 开始循环。循环累加 k 的值，直到 `nums[i] + nums[j] > nums[k]`，那么 `[nums[j + 1], nums[k - 1]]` 这个区间内的值都满足条件。满足条件的解个数增加 `k - j - 1` 个。j 再次递增 + 1，此时最内层的 k 不用从 j + 1 开始增加，只用从上次 k 开始增加即可。因为如果 `nums[i] + nums[j] > nums[k]`，如果这个 `nums[i] + nums[j + 1] > nums[m + 1]` 不等式成立，那么 m 一定不小于 k。所以内层循环 k 和 j 加起来的时间复杂度是 O(n)，最外层 i 的循环是 O(n)，这样优化以后，整体时间复杂度是 O(n^2)。
+- 可能有读者有疑问，三角形三条边的组成条件：任意两边之和大于第三边。`a + b > c`，`a + c > b`，`b + c > a`，此处为什么只判断了 `a + b > c` 呢？因为一开始进行了排序处理，使得 `a ≤ b ≤ c`，在这个前提下，`a + c > b`，`b + c > a` 是一定成立的。所以原问题便转化为只需关心 `a + b > c` 这一个不等式是否成立即可。此题的测试用例用有一种特殊情况，那就是其中一条边或者两条边长度为 0，那么 `a + b > c` 这个不等式一定不成立。综上，先排序预处理之后，只需要关心 `a + b > c` 这一个不等式是否成立即可。
+
+## 代码
+
+```go
+package leetcode
+
+import "sort"
+
+func triangleNumber(nums []int) int {
+	res := 0
+	sort.Ints(nums)
+	for i := 0; i < len(nums)-2; i++ {
+		k := i + 2
+		for j := i + 1; j < len(nums)-1 && nums[i] != 0; j++ {
+			for k < len(nums) && nums[i]+nums[j] > nums[k] {
+				k++
+			}
+			res += k - j - 1
+		}
+	}
+	return res
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0609.Find-Duplicate-File-in-System/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0617.Merge-Two-Binary-Trees/">下一页➡️</a></p>
+</div>

website/content/ChapterFour/0600~0699/0617.Merge-Two-Binary-Trees.md

@@ -82,6 +82,6 @@ func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0609.Find-Duplicate-File-in-System/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0611.Valid-Triangle-Number/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0600~0699/0622.Design-Circular-Queue/">下一页➡️</a></p>
 </div>