ok

侯利朋 · 侯利朋 · commit 084e3a9ea45e · 2019-08-30T18:53:32.000+08:00
diff --git a/1123.lowest-common-ancestor-of-deepest-leaves.go b/1123.lowest-common-ancestor-of-deepest-leaves.go
@@ -0,0 +1,40 @@
+/*
+ * @lc app=leetcode id=1123 lang=golang
+ *
+ * [1123] Lowest Common Ancestor of Deepest Leaves
+ */
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+// (8 ms) √ Your runtime beats 90.91 %
+// 返回子树深度相同的节点
+func lcaDeepestLeaves(root *TreeNode) *TreeNode {
+	if root == nil {
+		return root
+	}
+	ldep := depth(root.Left)
+	rdep := depth(root.Right)
+	if ldep == rdep {
+		return root
+	} else if ldep > rdep {
+		return lcaDeepestLeaves(root.Left)
+	}
+	return lcaDeepestLeaves(root.Right)
+}
+
+func depth(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	l := depth(root.Left)
+	r := depth(root.Right)
+	if l > r {
+		return l + 1
+	}
+	return r + 1
+}
diff --git a/508.most-frequent-subtree-sum.go b/508.most-frequent-subtree-sum.go
@@ -0,0 +1,47 @@
+/*
+ * @lc app=leetcode id=508 lang=golang
+ *
+ * [508] Most Frequent Subtree Sum
+ */
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+// 12 ms, faster than 68.85%
+// map缓存所有结果
+func findFrequentTreeSum(root *TreeNode) []int {
+	tmp := make(map[int]int)
+	sum(root, tmp)
+	maxTime := -1
+	rtn := []int{}
+	for k, v := range tmp {
+		if v > maxTime {
+			maxTime = v
+			rtn = append(rtn, k)
+			rtn = rtn[len(rtn)-1:]
+		} else if v == maxTime {
+			rtn = append(rtn, k)
+		}
+	}
+	return rtn
+}
+
+func sum(root *TreeNode, tmp map[int]int) int {
+	if root == nil {
+		return 0
+	}
+	l, r := 0, 0
+	if root.Left != nil {
+		l = sum(root.Left, tmp)
+	}
+	if root.Right != nil {
+		r = sum(root.Right, tmp)
+	}
+
+	tmp[l+r+root.Val]++ // 只在此处统计一次结果，在上面的left或right判断中不记录，否则会导致多计算一次
+	return l + r + root.Val
+}
diff --git a/865.smallest-subtree-with-all-the-deepest-nodes.go b/865.smallest-subtree-with-all-the-deepest-nodes.go
@@ -0,0 +1,43 @@
+/*
+ * @lc app=leetcode id=865 lang=golang
+ *
+ * [865] Smallest Subtree with all the Deepest Nodes
+ */
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+// (0 ms)
+func subtreeWithAllDeepest(root *TreeNode) *TreeNode {
+	if root == nil {
+		return root
+	}
+	ldep := depth(root.Left)
+	rdep := depth(root.Right)
+	if ldep == rdep {
+		return root
+	} else if ldep > rdep {
+		return subtreeWithAllDeepest(root.Left)
+	}
+	return subtreeWithAllDeepest(root.Right)
+}
+
+func depth(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	l := depth(root.Left)
+	r := depth(root.Right)
+	return max(l, r) + 1
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
diff --git a/951.flip-equivalent-binary-trees.go b/951.flip-equivalent-binary-trees.go
@@ -0,0 +1,27 @@
+/*
+ * @lc app=leetcode id=951 lang=golang
+ *
+ * [951] Flip Equivalent Binary Trees
+ */
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+//  (0 ms)
+func flipEquiv(root1 *TreeNode, root2 *TreeNode) bool {
+	if root1 == nil && root2 == nil {
+		return true
+	}
+	if root1 == nil || root2 == nil {
+		return false
+	}
+	if root1.Val != root2.Val {
+		return false
+	}
+	return (flipEquiv(root1.Left, root2.Left) && flipEquiv(root1.Right, root2.Right)) ||
+		(flipEquiv(root1.Left, root2.Right) && flipEquiv(root1.Right, root2.Left))
+}
diff --git a/998.maximum-binary-tree-ii.go b/998.maximum-binary-tree-ii.go
@@ -0,0 +1,28 @@
+/*
+ * @lc app=leetcode id=998 lang=golang
+ *
+ * [998] Maximum Binary Tree II
+ */
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+// 0 ms
+func insertIntoMaxTree(root *TreeNode, val int) *TreeNode {
+	if root == nil {
+		return &TreeNode{val, nil, nil}
+	}
+	if val > root.Val {
+		rtn := &TreeNode{}
+		rtn.Val = val
+		rtn.Left = root
+		return rtn
+	}
+	// 新的节点插入右子树，同时注意树的连接，不能断开
+	root.Right = insertIntoMaxTree(root.Right, val)
+	return root
+}
