Merge branch 'master' of https://github.com/halfrost/LeetCode-Go

Author: novahe

README.md

@@ -10,8 +10,9 @@ Rotate the image by 90 degrees (clockwise).
 
 You have to rotate the image **[in-place](https://en.wikipedia.org/wiki/In-place_algorithm)**, which means you have to modify the input 2D matrix directly. **DO NOT** allocate another 2D matrix and do the rotation.
 
-**Example 1:**
+**Example 1**:
 
+![](https://assets.leetcode.com/uploads/2020/08/28/mat1.jpg)
 
     Given input matrix = 
     [
@@ -28,8 +29,9 @@ You have to rotate the image **[in-place](https://en.wikipedia.org/wiki/In-plac
     ]
 
 
-**Example 2:**
+**Example 2**:
 
+![](https://assets.leetcode.com/uploads/2020/08/28/mat2.jpg)
 
     Given input matrix =
     [

leetcode/0048.Rotate-Image/README.md

@@ -16,19 +16,51 @@ type TreeNode = structures.TreeNode
  * }
  */
 
+// 解法一 dfs
 func isSymmetric(root *TreeNode) bool {
-	var dfs func(rootLeft, rootRight *TreeNode) bool
-	dfs = func(rootLeft, rootRight *TreeNode) bool {
-		if rootLeft == nil && rootRight == nil {
-			return true
-		}
-		if rootLeft == nil || rootRight == nil {
-			return false
-		}
-		if rootLeft.Val != rootRight.Val {
+	return root == nil || dfs(root.Left, root.Right)
+}
+
+func dfs(rootLeft, rootRight *TreeNode) bool {
+	if rootLeft == nil && rootRight == nil {
+		return true
+	}
+	if rootLeft == nil || rootRight == nil {
+		return false
+	}
+	if rootLeft.Val != rootRight.Val {
+		return false
+	}
+	return dfs(rootLeft.Left, rootRight.Right) && dfs(rootLeft.Right, rootRight.Left)
+}
+
+// 解法二
+func isSymmetric1(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+	return isSameTree(invertTree(root.Left), root.Right)
+}
+
+func isSameTree(p *TreeNode, q *TreeNode) bool {
+	if p == nil && q == nil {
+		return true
+	} else if p != nil && q != nil {
+		if p.Val != q.Val {
 			return false
 		}
-		return dfs(rootLeft.Left, rootRight.Right) && dfs(rootLeft.Right, rootRight.Left)
+		return isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right)
+	} else {
+		return false
 	}
-	return root == nil || dfs(root.Left, root.Right)
+}
+
+func invertTree(root *TreeNode) *TreeNode {
+	if root == nil {
+		return nil
+	}
+	invertTree(root.Left)
+	invertTree(root.Right)
+	root.Left, root.Right = root.Right, root.Left
+	return root
 }

leetcode/0101.Symmetric-Tree/101. Symmetric Tree.go

@@ -6,8 +6,83 @@ import (
 	"github.com/halfrost/LeetCode-Go/template"
 )
 
-// 解法一 线段树 Segment Tree，时间复杂度 O(n log n)
+// 解法一 树状数组，时间复杂度 O(n log n)
+const LEFTSIDE = 1
+const RIGHTSIDE = 2
+
+type Point struct {
+	xAxis int
+	side  int
+	index int
+}
+
 func getSkyline(buildings [][]int) [][]int {
+	res := [][]int{}
+	if len(buildings) == 0 {
+		return res
+	}
+	allPoints, bit := make([]Point, 0), BinaryIndexedTree{}
+	// [x-axis (value), [1 (left) | 2 (right)], index (building number)]
+	for i, b := range buildings {
+		allPoints = append(allPoints, Point{xAxis: b[0], side: LEFTSIDE, index: i})
+		allPoints = append(allPoints, Point{xAxis: b[1], side: RIGHTSIDE, index: i})
+	}
+	sort.Slice(allPoints, func(i, j int) bool {
+		if allPoints[i].xAxis == allPoints[j].xAxis {
+			return allPoints[i].side < allPoints[j].side
+		}
+		return allPoints[i].xAxis < allPoints[j].xAxis
+	})
+	bit.Init(len(allPoints))
+	kth := make(map[Point]int)
+	for i := 0; i < len(allPoints); i++ {
+		kth[allPoints[i]] = i
+	}
+	for i := 0; i < len(allPoints); i++ {
+		pt := allPoints[i]
+		if pt.side == LEFTSIDE {
+			bit.Add(kth[Point{xAxis: buildings[pt.index][1], side: RIGHTSIDE, index: pt.index}], buildings[pt.index][2])
+		}
+		currHeight := bit.Query(kth[pt] + 1)
+		if len(res) == 0 || res[len(res)-1][1] != currHeight {
+			if len(res) > 0 && res[len(res)-1][0] == pt.xAxis {
+				res[len(res)-1][1] = currHeight
+			} else {
+				res = append(res, []int{pt.xAxis, currHeight})
+			}
+		}
+	}
+	return res
+}
+
+type BinaryIndexedTree struct {
+	tree     []int
+	capacity int
+}
+
+// Init define
+func (bit *BinaryIndexedTree) Init(capacity int) {
+	bit.tree, bit.capacity = make([]int, capacity+1), capacity
+}
+
+// Add define
+func (bit *BinaryIndexedTree) Add(index int, val int) {
+	for ; index > 0; index -= index & -index {
+		bit.tree[index] = max(bit.tree[index], val)
+	}
+}
+
+// Query define
+func (bit *BinaryIndexedTree) Query(index int) int {
+	sum := 0
+	for ; index <= bit.capacity; index += index & -index {
+		sum = max(sum, bit.tree[index])
+	}
+	return sum
+}
+
+// 解法三 线段树 Segment Tree，时间复杂度 O(n log n)
+func getSkyline1(buildings [][]int) [][]int {
 	st, ans, lastHeight, check := template.SegmentTree{}, [][]int{}, 0, false
 	posMap, pos := discretization218(buildings)
 	tmp := make([]int, len(posMap))
@@ -54,8 +129,8 @@ func max(a int, b int) int {
 	return b
 }
 
-// 解法二 扫描线 Sweep Line，时间复杂度 O(n log n)
-func getSkyline1(buildings [][]int) [][]int {
+// 解法三 扫描线 Sweep Line，时间复杂度 O(n log n)
+func getSkyline2(buildings [][]int) [][]int {
 	size := len(buildings)
 	es := make([]E, 0)
 	for i, b := range buildings {

leetcode/0218.The-Skyline-Problem/218. The Skyline Problem.go

@@ -30,6 +30,16 @@ func Test_Problem218(t *testing.T) {
 			para218{[][]int{{2, 9, 10}, {3, 7, 15}, {5, 12, 12}, {15, 20, 10}, {19, 24, 8}}},
 			ans218{[][]int{{2, 10}, {3, 15}, {7, 12}, {12, 0}, {15, 10}, {20, 8}, {24, 0}}},
 		},
+
+		{
+			para218{[][]int{{1, 2, 1}, {1, 2, 2}, {1, 2, 3}, {2, 3, 1}, {2, 3, 2}, {2, 3, 3}}},
+			ans218{[][]int{{1, 3}, {3, 0}}},
+		},
+
+		{
+			para218{[][]int{{4, 9, 10}, {4, 9, 15}, {4, 9, 12}, {10, 12, 10}, {10, 12, 8}}},
+			ans218{[][]int{{4, 15}, {9, 0}, {10, 10}, {12, 0}}},
+		},
 	}
 
 	fmt.Printf("------------------------Leetcode Problem 218------------------------\n")

leetcode/0218.The-Skyline-Problem/218. The Skyline Problem_test.go

@@ -1,8 +1,6 @@
 package leetcode
 
-import (
-	"github.com/halfrost/LeetCode-Go/template"
-)
+import "github.com/halfrost/LeetCode-Go/template"
 
 // NumArray define
 type NumArray struct {
@@ -23,6 +21,11 @@ func (this *NumArray) Update(i int, val int) {
 	this.st.Update(i, val)
 }
 
+// SumRange define
+func (this *NumArray) SumRange(i int, j int) int {
+	return this.st.Query(i, j)
+}
+
 //解法二 prefixSum，sumRange 时间复杂度 O(1)
 
 // // NumArray define
@@ -60,6 +63,30 @@ func (this *NumArray) Update(i int, val int) {
 // 	return this.prefixSum[j]
 // }
 
+// 解法三 树状数组
+// type NumArray struct {
+// 	bit  template.BinaryIndexedTree
+// 	data []int
+// }
+
+// // Constructor define
+// func Constructor307(nums []int) NumArray {
+// 	bit := template.BinaryIndexedTree{}
+// 	bit.InitWithNums(nums)
+// 	return NumArray{bit: bit, data: nums}
+// }
+
+// // Update define
+// func (this *NumArray) Update(i int, val int) {
+// 	this.bit.Add(i+1, val-this.data[i])
+// 	this.data[i] = val
+// }
+
+// // SumRange define
+// func (this *NumArray) SumRange(i int, j int) int {
+// 	return this.bit.Query(j+1) - this.bit.Query(i)
+// }
+
 /**
  * Your NumArray object will be instantiated and called as such:
  * obj := Constructor(nums);

leetcode/0307.Range-Sum-Query---Mutable/307. Range Sum Query - Mutable.go

@@ -12,9 +12,25 @@ func Test_Problem307(t *testing.T) {
 	obj.Update(1, 2)
 	fmt.Printf("obj = %v\n", obj)
 	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(0, 2))
-}
 
-// SumRange define
-func (ma *NumArray) SumRange(i int, j int) int {
-	return ma.st.Query(i, j)
+	obj = Constructor307([]int{-1})
+	fmt.Printf("obj = %v\n", obj)
+	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(0, 0))
+	obj.Update(0, 1)
+	fmt.Printf("obj = %v\n", obj)
+	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(0, 0))
+
+	obj = Constructor307([]int{7, 2, 7, 2, 0})
+	fmt.Printf("obj = %v\n", obj)
+	obj.Update(4, 6)
+	obj.Update(0, 2)
+	obj.Update(0, 9)
+	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(4, 4))
+	obj.Update(3, 8)
+	fmt.Printf("obj = %v\n", obj)
+	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(0, 4))
+	obj.Update(4, 1)
+	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(0, 3))
+	fmt.Printf("SumRange(0,2) = %v\n", obj.SumRange(0, 4))
+	obj.Update(0, 4)
 }

leetcode/0307.Range-Sum-Query---Mutable/307. Range Sum Query - Mutable_test.go

@@ -48,3 +48,4 @@ sumRange(0, 2) -> 8
 - 给出一个数组，数组里面的数都是`**可变**`的，设计一个数据结构能够满足查询数组任意区间内元素的和。
 - 对比第 303 题，这一题由于数组里面的元素都是**`可变`**的，所以第一个想到的解法就是线段树，构建一颗线段树，父结点内存的是两个子结点的和，初始化建树的时间复杂度是 O(log n)，查询区间元素和的时间复杂度是 O(log n)，更新元素值的时间复杂度是 O(log n)。
 - 如果此题还用 prefixSum 的思路解答呢？那每次 update 操作的时间复杂度都是 O(n)，因为每次更改一个值，最坏情况就是所有的 prefixSum 都要更新一次。prefixSum 的方法在这道题上面也可以 AC，只不过时间排名在 5%，非常差。
+- 此题也可以用树状数组解决。代码很直白，区间查询即是两个区间前缀和相减。最简单的树状数组应用。

leetcode/0307.Range-Sum-Query---Mutable/README.md

@@ -6,6 +6,7 @@ import (
 	"github.com/halfrost/LeetCode-Go/template"
 )
 
+// 解法一 线段树
 func countSmaller(nums []int) []int {
 	if len(nums) == 0 {
 		return []int{}
@@ -35,3 +36,31 @@ func countSmaller(nums []int) []int {
 	}
 	return res
 }
+
+// 解法二 树状数组
+func countSmaller1(nums []int) []int {
+	// copy 一份原数组至所有数字 allNums 数组中
+	allNums, res := make([]int, len(nums)), []int{}
+	copy(allNums, nums)
+	// 将 allNums 离散化
+	sort.Ints(allNums)
+	k := 1
+	kth := map[int]int{allNums[0]: k}
+	for i := 1; i < len(allNums); i++ {
+		if allNums[i] != allNums[i-1] {
+			k++
+			kth[allNums[i]] = k
+		}
+	}
+	// 树状数组 Query
+	bit := template.BinaryIndexedTree{}
+	bit.Init(k)
+	for i := len(nums) - 1; i >= 0; i-- {
+		res = append(res, bit.Query(kth[nums[i]]-1))
+		bit.Add(kth[nums[i]], 1)
+	}
+	for i := 0; i < len(res)/2; i++ {
+		res[i], res[len(res)-1-i] = res[len(res)-1-i], res[i]
+	}
+	return res
+}

leetcode/0315.Count-of-Smaller-Numbers-After-Self/315. Count of Smaller Numbers After Self.go

@@ -39,3 +39,4 @@ You are given an integer array nums and you have to return a new counts arra
 
 - 给出一个数组，要求输出数组中每个元素相对于数组中的位置右边比它小的元素。
 - 这一题是第 327 题的缩水版。由于需要找数组位置右边比当前位置元素小的元素，所以从数组右边开始往左边扫。构造一颗线段树，线段树里面父节点存的是子节点出现的次数和。有可能给的数据会很大，所以构造线段树的时候先离散化。还需要注意的是数组里面可能有重复元素，所以构造线段树要先去重并排序。从右往左扫的过程中，依次添加数组中的元素，添加了一次就立即 query 一次。query 的区间是 [minNum, nums[i]-1]。如果是 minNum 则输出 0，并且也要记得插入这个最小值。这一题的思路和第 327 题大体类似，详解可见第 327 题。
+- 这一题同样可以用树状数组来解答。相比 327 题简单很多。第一步还是把所有用到的元素放入 allNums 数组中，第二步排序 + 离散化。由于题目要求输出右侧更小的元素，所以第三步倒序插入构造树状数组，Query 查询 `[1,i-1]` 区间内元素总数即为右侧更小元素个数。注意最终输出是顺序输出，计算是逆序计算的，最终数组里面的答案还需要逆序一遍。相同的套路题有，第 327 题，第 493 题。