init

Author: van0828

.gitignore

@@ -0,0 +1 @@
+.idea/

1.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println(twoSum([]int{2, 4, 9, 7, 7, 11, 15}, 9))
+}
+
+//给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
+//
+//你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
+//
+//示例:
+//
+//给定 nums = [2, 7, 11, 15], target = 9
+//
+//因为 nums[0] + nums[1] = 2 + 7 = 9
+//所以返回 [0, 1]
+
+// two-sum
+// 改进过 一开始两次循环
+func twoSum(nums []int, target int) []int {
+	var result []int
+	numsMap := make(map[int]int, 0)
+	for i := range nums {
+		tmp := target - nums[i]
+		if _, ok := numsMap[tmp]; ok {
+			result = []int{numsMap[tmp], i}
+		}
+		numsMap[nums[i]] = i
+	}
+	return result
+}

100.go

@@ -0,0 +1,47 @@
+package main
+
+//给定两个二叉树，编写一个函数来检验它们是否相同。
+//
+//如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
+//
+//示例 1:
+//
+//输入:       1         1
+//          / \       / \
+//         2   3     2   3
+//
+//        [1,2,3],   [1,2,3]
+//
+//输出: true
+//示例 2:
+//
+//输入:      1          1
+//          /           \
+//         2             2
+//
+//        [1,2],     [1,null,2]
+//
+//输出: false
+//示例 3:
+//
+//输入:       1         1
+//          / \       / \
+//         2   1     1   2
+//
+//        [1,2,1],   [1,1,2]
+//
+//输出: false
+//
+//来源：力扣（LeetCode）
+//链接：https://leetcode-cn.com/problems/same-tree
+//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+//func isSameTree(p *TreeNode, q *TreeNode) bool {
+//	if p == nil && q == nil {
+//		return true
+//	}
+//	return p != nil && q != nil &&
+//		p.Val == q.Val &&
+//		isSameTree(p.Left, q.Left) &&
+//		isSameTree(p.Right, q.Right)
+//}

101.go

@@ -0,0 +1,47 @@
+package main
+
+//给定一个二叉树，检查它是否是镜像对称的。
+//
+//
+//
+//例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
+//
+//    1
+//   / \
+//  2   2
+// / \ / \
+//3  4 4  3
+//
+//
+//但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
+//
+//    1
+//   / \
+//  2   2
+//   \   \
+//   3    3
+//
+//symmetric-tree
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func isMirror(r1, r2 *TreeNode) bool {
+	if r1 == nil && r2 == nil {
+		return true
+	}
+	if r1 == nil || r2 == nil {
+		return false
+	}
+	if r1.Val != r2.Val {
+		return false
+	}
+	return isMirror(r1.Left, r2.Right) && isMirror(r1.Right, r2.Left)
+}
+
+func isSymmetric(root *TreeNode) bool {
+	return isMirror(root, root)
+}

104.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"github.com/eapache/queue"
+)
+
+
+func main() {
+
+}
+
+//给定一个二叉树，找出其最大深度。
+//
+//二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+//maximum-depth-of-binary-tree
+func maxDepth(root *TreeNode) int {
+	/*
+		递归
+	 */
+	//if root == nil {
+	//	return 0
+	//} else {
+	//	return int(math.Max(float64(maxDepth(root.Left)), float64(maxDepth(root.Right)))) + 1
+	//}
+
+	/*
+		非递归
+	 */
+	if root == nil {
+		return 0
+	}
+	result := 0
+	queue1 := queue.New()
+	queue1.Add(root)
+	for queue1.Length() != 0 {
+		result++
+		queue2 := queue.New()
+		for queue1.Length() != 0 {
+			node := queue1.Remove().(*TreeNode)
+			if node.Left != nil {
+				queue2.Add(node.Left)
+			}
+			if node.Right != nil {
+				queue2.Add(node.Right)
+			}
+		}
+		queue1 = queue2
+	}
+	return result
+}

1042.go

@@ -0,0 +1,35 @@
+package main
+
+
+func main() {
+	gardenNoAdj(10,nil)
+}
+
+//有 N 个花园，按从 1 到 N 标记。在每个花园中，你打算种下四种花之一。
+//
+//paths[i] = [x, y] 描述了花园 x 到花园 y 的双向路径。
+//
+//另外，没有花园有 3 条以上的路径可以进入或者离开。
+//
+//你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。
+//
+//以数组形式返回选择的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用  1, 2, 3, 4 表示。保证存在答案。
+//
+//
+//
+//示例 1：
+//
+//输入：N = 3, paths = [[1,2],[2,3],[3,1]]
+//输出：[1,2,3]
+//示例 2：
+//
+//输入：N = 4, paths = [[1,2],[3,4]]
+//输出：[1,2,1,2]
+//示例 3：
+//
+//输入：N = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
+//输出：[1,2,3,4]
+//flower-planting-with-no-adjacent
+func gardenNoAdj(N int, paths [][]int) []int {
+
+}

108.go

@@ -0,0 +1,43 @@
+package main
+
+//将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
+//
+//本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
+//
+//示例:
+//
+//给定有序数组: [-10,-3,0,5,9],
+//
+//一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
+//
+//      0
+//     / \
+//   -3   9
+//   /   /
+// -10  5
+//
+//来源：力扣（LeetCode）
+//链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree
+//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func sortedArrayToBST(nums []int) *TreeNode {
+	if len(nums) == 0 {
+		return nil
+	}
+	mid := len(nums) / 2
+	left, right := nums[:mid], nums[mid+1:]
+	node := &TreeNode{
+		Val:   nums[mid],
+		Left:  sortedArrayToBST(left),
+		Right: sortedArrayToBST(right),
+	}
+	return node
+}

11.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"math"
+	"fmt"
+)
+
+func main() {
+	fmt.Println(maxArea([]int{1,8,6,2,5,4,8,3,7}))
+}
+
+//给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+//
+//说明：你不能倾斜容器，且 n 的值至少为 2。
+//示例:
+//
+//输入: [1,8,6,2,5,4,8,3,7]
+//输出: 49
+//container-with-most-water
+func maxArea(height []int) int {
+	res, l, r := 0, 0, len(height)-1
+	for l < r {
+		res = int(math.Max(float64(res), math.Min(float64(height[l]), float64(height[r]))*float64(r-l)))
+		if height[l] < height[r] {
+			l++
+		} else {
+			r--
+		}
+	}
+	return res
+}

1111.go

@@ -0,0 +1,78 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(maxDepthAfterSplit("()(())()"))
+}
+
+//有效括号字符串 定义：对于每个左括号，都能找到与之对应的右括号，反之亦然。详情参见题末「有效括号字符串」部分。
+//
+//嵌套深度 depth 定义：即有效括号字符串嵌套的层数，depth(A) 表示有效括号字符串 A 的嵌套深度。详情参见题末「嵌套深度」部分。
+//
+//有效括号字符串类型与对应的嵌套深度计算方法如下图所示：
+//
+//
+//给你一个「有效括号字符串」 seq，请你将其分成两个不相交的有效括号字符串，A 和 B，并使这两个字符串的深度最小。
+//
+//不相交：每个 seq[i] 只能分给 A 和 B 二者中的一个，不能既属于 A 也属于 B 。
+//A 或 B 中的元素在原字符串中可以不连续。
+//A.length + B.length = seq.length
+//深度最小：max(depth(A), depth(B)) 的可能取值最小。
+//划分方案用一个长度为 seq.length 的答案数组 answer 表示，编码规则如下：
+//
+//answer[i] = 0，seq[i] 分给 A 。
+//answer[i] = 1，seq[i] 分给 B 。
+//如果存在多个满足要求的答案，只需返回其中任意 一个 即可。
+//
+//
+//
+//示例 1：
+//
+//输入：seq = "(()())"
+//输出：[0,1,1,1,1,0]
+//示例 2：
+//
+//输入：seq = "()(())()"
+//输出：[0,0,0,1,1,0,1,1]
+//解释：本示例答案不唯一。
+//按此输出 A = "()()", B = "()()", max(depth(A), depth(B)) = 1 。
+//像 [1,1,1,0,0,1,1,1]，也是正确结果，其中 A = "()()()", B = "()", max(depth(A), depth(B)) = 1 。
+//
+//
+//提示：
+//
+//1 <= text.size <= 10000
+//
+//
+//有效括号字符串：
+//
+//仅由 "(" 和 ")" 构成的字符串，对于每个左括号，都能找到与之对应的右括号，反之亦然。
+//下述几种情况同样属于有效括号字符串：
+//
+//  1. 空字符串
+//  2. 连接，可以记作 AB（A 与 B 连接），其中 A 和 B 都是有效括号字符串
+//  3. 嵌套，可以记作 (A)，其中 A 是有效括号字符串
+//嵌套深度：
+//
+//类似地，我们可以定义任意有效括号字符串 s 的 嵌套深度 depth(S)：
+//
+//  1. s 为空时，depth("") = 0
+//  2. s 为 A 与 B 连接时，depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是有效括号字符串
+//  3. s 为嵌套情况，depth("(" + A + ")") = 1 + depth(A)，其中 A 是有效括号字符串
+//
+//例如：""，"()()"，和 "()(()())" 都是有效括号字符串，嵌套深度分别为 0，1，2，而 ")(" 和 "(()" 都不是有效括号字符串。
+//maximum-nesting-depth-of-two-valid-parentheses-strings
+
+func maxDepthAfterSplit(seq string) []int {
+	// 奇偶性直接判断 证明见leetcode
+	res := make([]int, len(seq))
+	for i, s := range seq {
+		if s == '(' {
+			res[i] = i & 1
+		} else {
+			res[i] = (i + 1) & 1
+		}
+	}
+	return res
+}