feat:1046. Last Stone Weight

Author: kimi0230

Leetcode/1046.Last-Stone-Weight/README.md

@@ -10,7 +10,7 @@ description: "1046.Last-Stone-Weight"
 license: ""
 images: []
 
-tags: [LeetCode, Go, Easy, Heap, Last Stone Weight]
+tags: [LeetCode, Go, Easy, Heap, Priority Queue, Last Stone Weight]
 categories: [LeetCode]
 
 featuredImage: ""
@@ -120,9 +120,13 @@ Explanation:
 5. 如果最大堆中有石頭，返回該石頭的重量，否則返回 0。
 這樣的做法確保每次都選擇最大的兩個石頭進行粉碎，最終留下的石頭重量就是可能的最後一個石頭的重量。
 
+參考 [0215 Kth Largest Element in an Array](../0215.Kth-Largest-Element-in-an-Array/README.md)
+
 ## Big O
-時間複雜 : ``
-空間複雜 : ``
+時間複雜 : `O(nlogn)`
+空間複雜 : `O(n)`
+
+`n` 是石頭數量. 每次從隊列中取出元素需要話`O(logn)` 的時間, 最多共需要需要粉碎 `n−1` 次石頭
 
 ## 來源
 * https://leetcode.com/problems/last-stone-weight/
@@ -132,6 +136,73 @@ Explanation:
 https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/1046.Last-Stone-Weight/main.go
 
 ```go
+package laststoneweight
+
+import (
+	"container/heap"
+	"fmt"
+	"sort"
+)
+
+/*
+// IntSlice attaches the methods of Interface to []int, sorting in increasing order.
+type IntSlice []int
+
+func (x IntSlice) Len() int           { return len(x) }
+func (x IntSlice) Less(i, j int) bool { return x[i] < x[j] }
+func (x IntSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+
+// Sort is a convenience method: x.Sort() calls Sort(x).
+func (x IntSlice) Sort() { Sort(x) }
+*/
+
+type hp struct {
+	sort.IntSlice
+}
+
+func (h hp) Less(i, j int) bool {
+	// 大到小排序
+	return h.IntSlice[i] > h.IntSlice[j]
+}
+
+func (h *hp) Push(v interface{}) {
+	h.IntSlice = append(h.IntSlice, v.(int))
+}
+
+func (h *hp) Pop() interface{} {
+	old := h.IntSlice
+	v := old[len(old)-1]
+	h.IntSlice = old[:len(old)-1]
+	return v
+}
+
+func (h *hp) PushInt(v int) {
+	heap.Push(h, v)
+}
+
+func (h *hp) PopInt() int {
+	return heap.Pop(h).(int)
+}
+
+// 時間複雜 O(nlogn), 空間複雜 O(n)
+// n 是石頭數量. 每次從隊列中取出元素需要話O(logn) 的時間, 最多共需要需要粉碎 n−1 次石頭
+func LastStoneWeight(stones []int) int {
+	q := &hp{stones}
+	heap.Init(q)
+	fmt.Println(q)
+	for q.Len() > 1 {
+		fmt.Println(q)
+		x, y := q.PopInt(), q.PopInt()
+		fmt.Printf("%d,%d\n", x, y)
+		if x > y {
+			q.PushInt(x - y)
+		}
+	}
+	if q.Len() > 0 {
+		return q.IntSlice[0]
+	}
+	return 0
+}
 
 ```
 

Leetcode/1046.Last-Stone-Weight/main.go

@@ -1,6 +1,67 @@
 package laststoneweight
 
-// 時間複雜 O(), 空間複雜 O()
-func LastStoneWeight(stones []int) int {
+import (
+	"container/heap"
+	"fmt"
+	"sort"
+)
+
+/*
+// IntSlice attaches the methods of Interface to []int, sorting in increasing order.
+type IntSlice []int
+
+func (x IntSlice) Len() int           { return len(x) }
+func (x IntSlice) Less(i, j int) bool { return x[i] < x[j] }
+func (x IntSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
 
+// Sort is a convenience method: x.Sort() calls Sort(x).
+func (x IntSlice) Sort() { Sort(x) }
+*/
+
+type hp struct {
+	sort.IntSlice
+}
+
+func (h hp) Less(i, j int) bool {
+	// 大到小排序
+	return h.IntSlice[i] > h.IntSlice[j]
+}
+
+func (h *hp) Push(v interface{}) {
+	h.IntSlice = append(h.IntSlice, v.(int))
+}
+
+func (h *hp) Pop() interface{} {
+	old := h.IntSlice
+	v := old[len(old)-1]
+	h.IntSlice = old[:len(old)-1]
+	return v
+}
+
+func (h *hp) PushInt(v int) {
+	heap.Push(h, v)
+}
+
+func (h *hp) PopInt() int {
+	return heap.Pop(h).(int)
+}
+
+// 時間複雜 O(nlogn), 空間複雜 O(n)
+// n 是石頭數量. 每次從隊列中取出元素需要話O(logn) 的時間, 最多共需要需要粉碎 n−1 次石頭
+func LastStoneWeight(stones []int) int {
+	q := &hp{stones}
+	heap.Init(q)
+	fmt.Println(q)
+	for q.Len() > 1 {
+		fmt.Println(q)
+		x, y := q.PopInt(), q.PopInt()
+		fmt.Printf("%d,%d\n", x, y)
+		if x > y {
+			q.PushInt(x - y)
+		}
+	}
+	if q.Len() > 0 {
+		return q.IntSlice[0]
+	}
+	return 0
 }

README.md

@@ -15,7 +15,7 @@ https://kimi0230.github.io/LeetcodeGolang/
     - [Linked List](#linked-list)
     - [HashSet \& HashMap](#hashset--hashmap)
     - [Stack \& Queue](#stack--queue)
-    - [Heap](#heap)
+    - [Heap \& Priority Queue](#heap--priority-queue)
     - [Disjoint Set Union](#disjoint-set-union)
     - [Trie](#trie)
     - [Binary Indexed Tree](#binary-indexed-tree)
@@ -100,10 +100,12 @@ https://kimi0230.github.io/LeetcodeGolang/
 | [0094](https://kimi0230.github.io/LeetcodeGolang/Leetcode/0094.Binary-Tree-Inorder-Traversal/) | [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/) | [Go](https://github.com/kimi0230/LeetcodeGolang/tree/master/Leetcode/0094.Binary-Tree-Inorder-Traversal) | Medium     | O(n) | O(1)  | Stack |
 
 
-#### Heap
+#### Heap & Priority Queue
 | No.                                                                                              |                                               Title                                               |                                                  Solution                                                  | Difficulty | Time             | Space | Topic                |
 |--------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------:|------------|------------------|-------|----------------------|
 | [0703](https://kimi0230.github.io/LeetcodeGolang/Leetcode/0703.Kth-Largest-Element-in-a-Stream/) | [Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/) | [Go](https://github.com/kimi0230/LeetcodeGolang/tree/master/Leetcode/0703.Kth-Largest-Element-in-a-Stream) | Easy       | O(K + (N-K)logK) | O(k)  | Heap, Priority Queue |
+| [1046](https://kimi0230.github.io/LeetcodeGolang/Leetcode/1046.Last-Stone-Weight/)               |               [Last Stone Weight](https://leetcode.com/problems/last-stone-weight/)               |        [Go](https://github.com/kimi0230/LeetcodeGolang/tree/master/Leetcode/1046.Last-Stone-Weight)        | Easy       | O(nlogn)         | O(n)  | Heap, Priority Queue |
+
 
 #### Disjoint Set Union