feat: add solutions to lc problem: No.1199

No.1199.Minimum Time to Build Blocks

Author: yanglbme

solution/1100-1199/1199.Minimum Time to Build Blocks/README.md

@@ -58,22 +58,99 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：贪心 + 优先队列（小根堆）**
+
+先考虑只有一个街区的情况，此时不需要分裂工人，直接让他去建造街区，时间花费为 `block[0]`。
+
+如果有两个街区，此时需要把工人分裂为两个，然后让他们分别去建造街区，时间花费为 `split + max(block[0], block[1])`。
+
+如果有超过两个街区，此时每一步都需要考虑将几个工人进行分裂，正向思维不好处理。
+
+我们不妨采用逆向思维，不分裂工人，而是将街区进行合并。我们选取任意两个街区 $i$, $j$ 进行合并，建造一个新的街区的时间为 `split + max(block[i], block[j])`。
+
+为了让耗时长的街区尽可能少参与到合并中，我们可以每次贪心地选取耗时最小的两个街区进行合并。因此，我们可以维护一个小根堆，每次取出最小的两个街区进行合并，直到只剩下一个街区。最后剩下的这个街区的建造时间就是答案。
+
+时间复杂度 $O(n\log n)$。其中 $n$ 是街区数量。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minBuildTime(self, blocks: List[int], split: int) -> int:
+        heapify(blocks)
+        while len(blocks) > 1:
+            heappop(blocks)
+            heappush(blocks, heappop(blocks) + split)
+        return blocks[0]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int minBuildTime(int[] blocks, int split) {
+        PriorityQueue<Integer> q = new PriorityQueue<>();
+        for (int x : blocks) {
+            q.offer(x);
+        }
+        while (q.size() > 1) {
+            q.poll();
+            q.offer(q.poll() + split);
+        }
+        return q.poll();
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int minBuildTime(vector<int>& blocks, int split) {
+        priority_queue<int, vector<int>, greater<int>> pq;
+        for (int v : blocks) pq.push(v);
+        while (pq.size() > 1) {
+            pq.pop();
+            int x = pq.top();
+            pq.pop();
+            pq.push(x + split);
+        }
+        return pq.top();
+    }
+};
+```
 
+### **Go**
+
+```go
+func minBuildTime(blocks []int, split int) int {
+	q := hp{}
+	for _, v := range blocks {
+		heap.Push(&q, v)
+	}
+	for q.Len() > 1 {
+		heap.Pop(&q)
+		heap.Push(&q, heap.Pop(&q).(int)+split)
+	}
+	return q.IntSlice[0]
+}
+
+type hp struct{ sort.IntSlice }
+
+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
+}
 ```
 
 ### **...**

solution/1100-1199/1199.Minimum Time to Build Blocks/README_EN.md

@@ -57,13 +57,76 @@ The cost is 1 + max(3, 1 + max(1, 2)) = 4.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def minBuildTime(self, blocks: List[int], split: int) -> int:
+        heapify(blocks)
+        while len(blocks) > 1:
+            heappop(blocks)
+            heappush(blocks, heappop(blocks) + split)
+        return blocks[0]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int minBuildTime(int[] blocks, int split) {
+        PriorityQueue<Integer> q = new PriorityQueue<>();
+        for (int x : blocks) {
+            q.offer(x);
+        }
+        while (q.size() > 1) {
+            q.poll();
+            q.offer(q.poll() + split);
+        }
+        return q.poll();
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int minBuildTime(vector<int>& blocks, int split) {
+        priority_queue<int, vector<int>, greater<int>> pq;
+        for (int v : blocks) pq.push(v);
+        while (pq.size() > 1) {
+            pq.pop();
+            int x = pq.top();
+            pq.pop();
+            pq.push(x + split);
+        }
+        return pq.top();
+    }
+};
+```
 
+### **Go**
+
+```go
+func minBuildTime(blocks []int, split int) int {
+	q := hp{}
+	for _, v := range blocks {
+		heap.Push(&q, v)
+	}
+	for q.Len() > 1 {
+		heap.Pop(&q)
+		heap.Push(&q, heap.Pop(&q).(int)+split)
+	}
+	return q.IntSlice[0]
+}
+
+type hp struct{ sort.IntSlice }
+
+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
+}
 ```
 
 ### **...**

solution/1100-1199/1199.Minimum Time to Build Blocks/Solution.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int minBuildTime(vector<int>& blocks, int split) {
+        priority_queue<int, vector<int>, greater<int>> pq;
+        for (int v : blocks) pq.push(v);
+        while (pq.size() > 1) {
+            pq.pop();
+            int x = pq.top();
+            pq.pop();
+            pq.push(x + split);
+        }
+        return pq.top();
+    }
+};

solution/1100-1199/1199.Minimum Time to Build Blocks/Solution.go

@@ -0,0 +1,21 @@
+func minBuildTime(blocks []int, split int) int {
+	q := hp{}
+	for _, v := range blocks {
+		heap.Push(&q, v)
+	}
+	for q.Len() > 1 {
+		heap.Pop(&q)
+		heap.Push(&q, heap.Pop(&q).(int)+split)
+	}
+	return q.IntSlice[0]
+}
+
+type hp struct{ sort.IntSlice }
+
+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
+}

solution/1100-1199/1199.Minimum Time to Build Blocks/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    public int minBuildTime(int[] blocks, int split) {
+        PriorityQueue<Integer> q = new PriorityQueue<>();
+        for (int x : blocks) {
+            q.offer(x);
+        }
+        while (q.size() > 1) {
+            q.poll();
+            q.offer(q.poll() + split);
+        }
+        return q.poll();
+    }
+}

solution/1100-1199/1199.Minimum Time to Build Blocks/Solution.py

@@ -0,0 +1,7 @@
+class Solution:
+    def minBuildTime(self, blocks: List[int], split: int) -> int:
+        heapify(blocks)
+        while len(blocks) > 1:
+            heappop(blocks)
+            heappush(blocks, heappop(blocks) + split)
+        return blocks[0]