feat: add solutions to lc problem: No.1167

No.1167.Minimum Cost to Connect Sticks

Author: yanglbme

solution/1100-1199/1167.Minimum Cost to Connect Sticks/README.md

@@ -58,7 +58,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-优先队列。
+**方法一：贪心 + 优先队列（小根堆）**
+
+我们可以使用贪心的思路，每次选择最短的两根棍子进行拼接，这样可以保证拼接的代价最小。
+
+因此，我们可以使用优先队列（小根堆）来维护当前棍子的长度，每次从优先队列中取出两根棍子进行拼接，再将拼接后的棍子放回优先队列中，直到优先队列中只剩下一根棍子为止。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `sticks` 的长度。
 
 <!-- tabs:start -->
 
@@ -69,15 +75,13 @@
 ```python
 class Solution:
     def connectSticks(self, sticks: List[int]) -> int:
-        h = []
-        for s in sticks:
-            heappush(h, s)
-        res = 0
-        while len(h) > 1:
-            val = heappop(h) + heappop(h)
-            res += val
-            heappush(h, val)
-        return res
+        heapify(sticks)
+        ans = 0
+        while len(sticks) > 1:
+            z = heappop(sticks) + heappop(sticks)
+            ans += z
+            heappush(sticks, z)
+        return ans
 ```
 
 ### **Java**
@@ -88,16 +92,16 @@ class Solution:
 class Solution {
     public int connectSticks(int[] sticks) {
         PriorityQueue<Integer> pq = new PriorityQueue<>();
-        for (int s : sticks) {
-            pq.offer(s);
+        for (int x : sticks) {
+            pq.offer(x);
         }
-        int res = 0;
+        int ans = 0;
         while (pq.size() > 1) {
-            int val = pq.poll() + pq.poll();
-            res += val;
-            pq.offer(val);
+            int z = pq.poll() + pq.poll();
+            ans += z;
+            pq.offer(z);
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -109,51 +113,130 @@ class Solution {
 public:
     int connectSticks(vector<int>& sticks) {
         priority_queue<int, vector<int>, greater<int>> pq;
-        for (int x : sticks) pq.push(x);
-        int res = 0;
+        for (auto& x : sticks) {
+            pq.push(x);
+        }
+        int ans = 0;
         while (pq.size() > 1) {
-            int val = pq.top();
+            int x = pq.top();
             pq.pop();
-            val += pq.top();
+            int y = pq.top();
             pq.pop();
-            res += val;
-            pq.push(val);
+            int z = x + y;
+            ans += z;
+            pq.push(z);
         }
-        return res;
+        return ans;
     }
 };
 ```
 
 ### **Go**
 
 ```go
-func connectSticks(sticks []int) int {
-	h := IntHeap(sticks)
-	heap.Init(&h)
-	res := 0
-	for h.Len() > 1 {
-		val := heap.Pop(&h).(int)
-		val += heap.Pop(&h).(int)
-		res += val
-		heap.Push(&h, val)
+func connectSticks(sticks []int) (ans int) {
+	hp := &hp{sticks}
+	heap.Init(hp)
+	for hp.Len() > 1 {
+		x, y := heap.Pop(hp).(int), heap.Pop(hp).(int)
+		ans += x + y
+		heap.Push(hp, x+y)
 	}
-	return res
+	return
 }
 
-type IntHeap []int
+type hp struct{ sort.IntSlice }
 
-func (h IntHeap) Len() int           { return len(h) }
-func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
-func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
-func (h *IntHeap) Push(x interface{}) {
-	*h = append(*h, x.(int))
+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{} {
+	a := h.IntSlice
+	v := a[len(a)-1]
+	h.IntSlice = a[:len(a)-1]
+	return v
 }
-func (h *IntHeap) Pop() interface{} {
-	old := *h
-	n := len(old)
-	x := old[n-1]
-	*h = old[0 : n-1]
-	return x
+```
+
+### **TypeScript**
+
+```ts
+function connectSticks(sticks: number[]): number {
+    const pq = new Heap(sticks);
+    let ans = 0;
+    while (pq.size() > 1) {
+        const x = pq.pop();
+        const y = pq.pop();
+        ans += x + y;
+        pq.push(x + y);
+    }
+    return ans;
+}
+
+type Compare<T> = (lhs: T, rhs: T) => number;
+
+class Heap<T = number> {
+    data: Array<T | null>;
+    lt: (i: number, j: number) => boolean;
+    constructor();
+    constructor(data: T[]);
+    constructor(compare: Compare<T>);
+    constructor(data: T[], compare: Compare<T>);
+    constructor(data: T[] | Compare<T>, compare?: (lhs: T, rhs: T) => number);
+    constructor(
+        data: T[] | Compare<T> = [],
+        compare: Compare<T> = (lhs: T, rhs: T) =>
+            lhs < rhs ? -1 : lhs > rhs ? 1 : 0,
+    ) {
+        if (typeof data === 'function') {
+            compare = data;
+            data = [];
+        }
+        this.data = [null, ...data];
+        this.lt = (i, j) => compare(this.data[i]!, this.data[j]!) < 0;
+        for (let i = this.size(); i > 0; i--) this.heapify(i);
+    }
+
+    size(): number {
+        return this.data.length - 1;
+    }
+
+    push(v: T): void {
+        this.data.push(v);
+        let i = this.size();
+        while (i >> 1 !== 0 && this.lt(i, i >> 1)) this.swap(i, (i >>= 1));
+    }
+
+    pop(): T {
+        this.swap(1, this.size());
+        const top = this.data.pop();
+        this.heapify(1);
+        return top!;
+    }
+
+    top(): T {
+        return this.data[1]!;
+    }
+    heapify(i: number): void {
+        while (true) {
+            let min = i;
+            const [l, r, n] = [i * 2, i * 2 + 1, this.data.length];
+            if (l < n && this.lt(l, min)) min = l;
+            if (r < n && this.lt(r, min)) min = r;
+            if (min !== i) {
+                this.swap(i, min);
+                i = min;
+            } else break;
+        }
+    }
+
+    clear(): void {
+        this.data = [null];
+    }
+
+    private swap(i: number, j: number): void {
+        const d = this.data;
+        [d[i], d[j]] = [d[j], d[i]];
+    }
 }
 ```