Skip to content

Commit b812355

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1834
No.1834.Single-Threaded CPU
1 parent 6565496 commit b812355

File tree

6 files changed

+353
-2
lines changed

6 files changed

+353
-2
lines changed

‎solution/1800-1899/1834.Single-Threaded CPU/README.md

+130-1
Original file line numberDiff line numberDiff line change
@@ -64,22 +64,151 @@
6464

6565
<!-- 这里可写通用的实现逻辑 -->
6666

67+
**方法一：排序 + 优先队列（小根堆）**
68+
69+
我们先将任务按照 `enqueueTime` 从小到大排序，接下来用一个优先队列（小根堆）维护当前可执行的任务，队列中的元素为 `(processingTime, index)`，即任务的执行时间和任务的编号。另外用一个变量 $t$ 表示当前时间，初始值为 $0$。
70+
71+
接下来我们模拟任务的执行过程。
72+
73+
如果当前队列为空，说明当前没有可执行的任务，我们将 $t$ 更新为下一个任务的 `enqueueTime` 与当前时间 $t$ 中的较大值。接下来将所有 `enqueueTime` 小于等于 $t$ 的任务加入队列。
74+
75+
然后从队列中取出一个任务，将其编号加入答案数组，然后将 $t$ 更新为当前时间 $t$ 与当前任务的执行时间之和。
76+
77+
循环上述过程，直到队列为空，且所有任务都已经加入过队列。
78+
79+
时间复杂度 $O(n \times \log n)$，其中 $n$ 为任务的数量。
80+
6781
<!-- tabs:start -->
6882

6983
### **Python3**
7084

7185
<!-- 这里可写当前语言的特殊实现逻辑 -->
7286

7387
```python
74-
88+
class Solution:
89+
def getOrder(self, tasks: List[List[int]]) -> List[int]:
90+
for i, task in enumerate(tasks):
91+
task.append(i)
92+
tasks.sort()
93+
ans = []
94+
q = []
95+
n = len(tasks)
96+
i = t = 0
97+
while q or i < n:
98+
if not q:
99+
t = max(t, tasks[i][0])
100+
while i < n and tasks[i][0] <= t:
101+
heappush(q, (tasks[i][1], tasks[i][2]))
102+
i += 1
103+
pt, j = heappop(q)
104+
ans.append(j)
105+
t += pt
106+
return ans
75107
```
76108

77109
### **Java**
78110

79111
<!-- 这里可写当前语言的特殊实现逻辑 -->
80112

81113
```java
114+
class Solution {
115+
public int[] getOrder(int[][] tasks) {
116+
int n = tasks.length;
117+
int[][] ts = new int[n][3];
118+
for (int i = 0; i < n; ++i) {
119+
ts[i] = new int[] {tasks[i][0], tasks[i][1], i};
120+
}
121+
Arrays.sort(ts, (a, b) -> a[0] - b[0]);
122+
int[] ans = new int[n];
123+
PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
124+
int i = 0, t = 0, k = 0;
125+
while (!q.isEmpty() || i < n) {
126+
if (q.isEmpty()) {
127+
t = Math.max(t, ts[i][0]);
128+
}
129+
while (i < n && ts[i][0] <= t) {
130+
q.offer(new int[] {ts[i][1], ts[i][2]});
131+
++i;
132+
}
133+
var p = q.poll();
134+
ans[k++] = p[1];
135+
t += p[0];
136+
}
137+
return ans;
138+
}
139+
}
140+
```
141+
142+
### **C++**
143+
144+
```cpp
145+
class Solution {
146+
public:
147+
vector<int> getOrder(vector<vector<int>>& tasks) {
148+
int n = 0;
149+
for (auto& task : tasks) task.push_back(n++);
150+
sort(tasks.begin(), tasks.end());
151+
using pii = pair<int, int>;
152+
priority_queue<pii, vector<pii>, greater<pii>> q;
153+
int i = 0;
154+
long long t = 0;
155+
vector<int> ans;
156+
while (!q.empty() || i < n) {
157+
if (q.empty()) t = max(t, (long long) tasks[i][0]);
158+
while (i < n && tasks[i][0] <= t) {
159+
q.push({tasks[i][1], tasks[i][2]});
160+
++i;
161+
}
162+
auto [pt, j] = q.top();
163+
q.pop();
164+
ans.push_back(j);
165+
t += pt;
166+
}
167+
return ans;
168+
}
169+
};
170+
```
82171
172+
### **Go**
173+
174+
```go
175+
func getOrder(tasks [][]int) (ans []int) {
176+
for i := range tasks {
177+
tasks[i] = append(tasks[i], i)
178+
}
179+
sort.Slice(tasks, func(i, j int) bool { return tasks[i][0] < tasks[j][0] })
180+
q := hp{}
181+
i, t, n := 0, 0, len(tasks)
182+
for len(q) > 0 || i < n {
183+
if len(q) == 0 {
184+
t = max(t, tasks[i][0])
185+
}
186+
for i < n && tasks[i][0] <= t {
187+
heap.Push(&q, pair{tasks[i][1], tasks[i][2]})
188+
i++
189+
}
190+
p := heap.Pop(&q).(pair)
191+
ans = append(ans, p.i)
192+
t += p.t
193+
}
194+
return
195+
}
196+
197+
func max(a, b int) int {
198+
if a > b {
199+
return a
200+
}
201+
return b
202+
}
203+
204+
type pair struct{ t, i int }
205+
type hp []pair
206+
207+
func (h hp) Len() int { return len(h) }
208+
func (h hp) Less(i, j int) bool { return h[i].t < h[j].t || (h[i].t == h[j].t && h[i].i < h[j].i) }
209+
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
210+
func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
211+
func (h *hp) Pop() interface{} { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
83212
```
84213

85214
### **...**

‎solution/1800-1899/1834.Single-Threaded CPU/README_EN.md

+116-1
Original file line numberDiff line numberDiff line change
@@ -66,13 +66,128 @@
6666
### **Python3**
6767

6868
```python
69-
69+
class Solution:
70+
def getOrder(self, tasks: List[List[int]]) -> List[int]:
71+
for i, task in enumerate(tasks):
72+
task.append(i)
73+
tasks.sort()
74+
ans = []
75+
q = []
76+
n = len(tasks)
77+
i = t = 0
78+
while q or i < n:
79+
if not q:
80+
t = max(t, tasks[i][0])
81+
while i < n and tasks[i][0] <= t:
82+
heappush(q, (tasks[i][1], tasks[i][2]))
83+
i += 1
84+
pt, j = heappop(q)
85+
ans.append(j)
86+
t += pt
87+
return ans
7088
```
7189

7290
### **Java**
7391

7492
```java
93+
class Solution {
94+
public int[] getOrder(int[][] tasks) {
95+
int n = tasks.length;
96+
int[][] ts = new int[n][3];
97+
for (int i = 0; i < n; ++i) {
98+
ts[i] = new int[] {tasks[i][0], tasks[i][1], i};
99+
}
100+
Arrays.sort(ts, (a, b) -> a[0] - b[0]);
101+
int[] ans = new int[n];
102+
PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
103+
int i = 0, t = 0, k = 0;
104+
while (!q.isEmpty() || i < n) {
105+
if (q.isEmpty()) {
106+
t = Math.max(t, ts[i][0]);
107+
}
108+
while (i < n && ts[i][0] <= t) {
109+
q.offer(new int[] {ts[i][1], ts[i][2]});
110+
++i;
111+
}
112+
var p = q.poll();
113+
ans[k++] = p[1];
114+
t += p[0];
115+
}
116+
return ans;
117+
}
118+
}
119+
```
120+
121+
### **C++**
122+
123+
```cpp
124+
class Solution {
125+
public:
126+
vector<int> getOrder(vector<vector<int>>& tasks) {
127+
int n = 0;
128+
for (auto& task : tasks) task.push_back(n++);
129+
sort(tasks.begin(), tasks.end());
130+
using pii = pair<int, int>;
131+
priority_queue<pii, vector<pii>, greater<pii>> q;
132+
int i = 0;
133+
long long t = 0;
134+
vector<int> ans;
135+
while (!q.empty() || i < n) {
136+
if (q.empty()) t = max(t, (long long) tasks[i][0]);
137+
while (i < n && tasks[i][0] <= t) {
138+
q.push({tasks[i][1], tasks[i][2]});
139+
++i;
140+
}
141+
auto [pt, j] = q.top();
142+
q.pop();
143+
ans.push_back(j);
144+
t += pt;
145+
}
146+
return ans;
147+
}
148+
};
149+
```
75150
151+
### **Go**
152+
153+
```go
154+
func getOrder(tasks [][]int) (ans []int) {
155+
for i := range tasks {
156+
tasks[i] = append(tasks[i], i)
157+
}
158+
sort.Slice(tasks, func(i, j int) bool { return tasks[i][0] < tasks[j][0] })
159+
q := hp{}
160+
i, t, n := 0, 0, len(tasks)
161+
for len(q) > 0 || i < n {
162+
if len(q) == 0 {
163+
t = max(t, tasks[i][0])
164+
}
165+
for i < n && tasks[i][0] <= t {
166+
heap.Push(&q, pair{tasks[i][1], tasks[i][2]})
167+
i++
168+
}
169+
p := heap.Pop(&q).(pair)
170+
ans = append(ans, p.i)
171+
t += p.t
172+
}
173+
return
174+
}
175+
176+
func max(a, b int) int {
177+
if a > b {
178+
return a
179+
}
180+
return b
181+
}
182+
183+
type pair struct{ t, i int }
184+
type hp []pair
185+
186+
func (h hp) Len() int { return len(h) }
187+
func (h hp) Less(i, j int) bool { return h[i].t < h[j].t || (h[i].t == h[j].t && h[i].i < h[j].i) }
188+
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
189+
func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
190+
func (h *hp) Pop() interface{} { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
76191
```
77192

78193
### **...**

‎solution/1800-1899/1834.Single-Threaded CPU/Solution.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
vector<int> getOrder(vector<vector<int>>& tasks) {
4+
int n = 0;
5+
for (auto& task : tasks) task.push_back(n++);
6+
sort(tasks.begin(), tasks.end());
7+
using pii = pair<int, int>;
8+
priority_queue<pii, vector<pii>, greater<pii>> q;
9+
int i = 0;
10+
long long t = 0;
11+
vector<int> ans;
12+
while (!q.empty() || i < n) {
13+
if (q.empty()) t = max(t, (long long) tasks[i][0]);
14+
while (i < n && tasks[i][0] <= t) {
15+
q.push({tasks[i][1], tasks[i][2]});
16+
++i;
17+
}
18+
auto [pt, j] = q.top();
19+
q.pop();
20+
ans.push_back(j);
21+
t += pt;
22+
}
23+
return ans;
24+
}
25+
};

‎solution/1800-1899/1834.Single-Threaded CPU/Solution.go

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
func getOrder(tasks [][]int) (ans []int) {
2+
for i := range tasks {
3+
tasks[i] = append(tasks[i], i)
4+
}
5+
sort.Slice(tasks, func(i, j int) bool { return tasks[i][0] < tasks[j][0] })
6+
q := hp{}
7+
i, t, n := 0, 0, len(tasks)
8+
for len(q) > 0 || i < n {
9+
if len(q) == 0 {
10+
t = max(t, tasks[i][0])
11+
}
12+
for i < n && tasks[i][0] <= t {
13+
heap.Push(&q, pair{tasks[i][1], tasks[i][2]})
14+
i++
15+
}
16+
p := heap.Pop(&q).(pair)
17+
ans = append(ans, p.i)
18+
t += p.t
19+
}
20+
return
21+
}
22+
23+
func max(a, b int) int {
24+
if a > b {
25+
return a
26+
}
27+
return b
28+
}
29+
30+
type pair struct{ t, i int }
31+
type hp []pair
32+
33+
func (h hp) Len() int { return len(h) }
34+
func (h hp) Less(i, j int) bool { return h[i].t < h[j].t || (h[i].t == h[j].t && h[i].i < h[j].i) }
35+
func (h hp) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
36+
func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
37+
func (h *hp) Pop() interface{} { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }

‎solution/1800-1899/1834.Single-Threaded CPU/Solution.java

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public int[] getOrder(int[][] tasks) {
3+
int n = tasks.length;
4+
int[][] ts = new int[n][3];
5+
for (int i = 0; i < n; ++i) {
6+
ts[i] = new int[] {tasks[i][0], tasks[i][1], i};
7+
}
8+
Arrays.sort(ts, (a, b) -> a[0] - b[0]);
9+
int[] ans = new int[n];
10+
PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
11+
int i = 0, t = 0, k = 0;
12+
while (!q.isEmpty() || i < n) {
13+
if (q.isEmpty()) {
14+
t = Math.max(t, ts[i][0]);
15+
}
16+
while (i < n && ts[i][0] <= t) {
17+
q.offer(new int[] {ts[i][1], ts[i][2]});
18+
++i;
19+
}
20+
var p = q.poll();
21+
ans[k++] = p[1];
22+
t += p[0];
23+
}
24+
return ans;
25+
}
26+
}

‎solution/1800-1899/1834.Single-Threaded CPU/Solution.py

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution:
2+
def getOrder(self, tasks: List[List[int]]) -> List[int]:
3+
for i, task in enumerate(tasks):
4+
task.append(i)
5+
tasks.sort()
6+
ans = []
7+
q = []
8+
n = len(tasks)
9+
i = t = 0
10+
while q or i < n:
11+
if not q:
12+
t = max(t, tasks[i][0])
13+
while i < n and tasks[i][0] <= t:
14+
heappush(q, (tasks[i][1], tasks[i][2]))
15+
i += 1
16+
pt, j = heappop(q)
17+
ans.append(j)
18+
t += pt
19+
return ans

0 commit comments

Comments
 (0)