Update bit

leetcode/0218.The-Skyline-Problem/218. The Skyline Problem.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_test.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")