我需要模拟给定一组任务的执行。 这意味着您需要跟踪在任何给定时间点哪些任务处于活动状态，并在完成时将它们从活动列表中删除。
我需要使用优先级队列来解决此问题，并使用 binary heap 来实现。
输入包含一组以开始时间从小到大的顺序给出的任务，并且每个任务都有一定的持续时间。 第一行是任务数，例如
3
2 5
4 23
7 4
这意味着有3个任务。第一个开始于时间2，结束于7（2 + 5）。第二个开始于4，结束于27。第三个开始于7，结束于11。
我们可以跟踪活动任务的数量：
Time #tasks
0 - 2 0
2 - 4 1
4 - 11 2
11 - 27 1
我需要找到：
[0 *（2-0）+ 1 *（4-2）+ 2 *（11-4）+ 1 *（27-11）] / 27
我编写了以下代码以将时间值读入结构：
#include "stdio.h"
#include "stdlib.h"
typedef struct
{
long int start;
long int end;
int dur;
} task;
int main()
{
long int num_tasks;
scanf("%ld",&num_tasks);
task *t = new task[num_tasks];
for (int i=0;i<num_tasks;i++)
{
scanf("%ld %d",&t[i].start,&t[i].dur);
t[i].end = t[i].start + t[i].dur;
}
}
我想了解如何将其实现为堆优先级队列，并从堆中获取必要的输出。
答案 0 :(得分：0)
可以通过使用两个堆来解决此问题，一个堆包含开始时间，另一个堆包含结束时间。阅读任务时，将开始时间和结束时间添加到两个堆中。然后算法看起来像这样：
number_of_tasks = 0
while start_heap not empty
if min_start_time < min_end_time
pop min_start_time
number_of_tasks += 1
else if min_end_time < min_start_time
pop min_end_time
number_of_tasks -= 1
else
pop min_start_time
pop min_end_time
while end_heap not empty
pop min_end_time
number_of_tasks -= 1
答案 1 :(得分：0)
由于您说过伪代码足以满足您的需求，所以我很信服您。以下是在Ruby中实现的，就像可运行的伪代码一样。我也对此进行了广泛评论。
此处概述的方法仅需要一个优先级队列。您的模型从概念上围绕两个事件-任务开始时和任务结束时。一种非常灵活的离散事件实现机制是使用优先级队列来存储事件通知，该事件通知按事件触发的时间排序。每个事件都实现为单独的方法/函数，该函数执行与事件相关联的任何状态转换，并且可以通过将事件通知放在优先级队列上来安排其他事件。然后，您需要一个执行循环，该循环将事件通知从优先级队列中拉出，将时钟更新为当前事件的时间，并调用相应的事件方法。有关此方法的更多信息，请参见this paper。本文用Java实现了这些概念，但是可以（也可以）以许多其他语言来实现它们。
事不宜迟，这是您的案例的有效实现方式：
# User needs to type "gem install simplekit" on the command line to
# snag a copy of this library from the public gem repository
require 'simplekit' # contains a PriorityQueue implementation
# define an "event notice" structure which stores the tag for an event method,
# the time the event should occur, and what arguments are to be passed to it.
EVENT_NOTICE = Struct.new(:event, :time, :args) {
include Comparable
def <=>(other) # define a comparison ordering based on my time vs other's time
return time - other.time # comparison of two times is positive, zero, or negative
end
}
@pq = PriorityQueue.new # @ makes globally shared (not really, but close enough for illustration purposes)
@num_tasks = 0 # number of tasks currently active
@clock = 0 # current time in the simulation
# define a report method
def report()
puts "#{@clock}: #{@num_tasks}" # print current simulation time & num_tasks
end
# define an event for starting a task, that increments the @num_tasks counter
# and uses the @clock and task duration to schedule when this task will end
# by pushing a suitable EVENT_NOTICE onto the priority queue.
def start_task(current_task)
@num_tasks += 1
@pq.push(EVENT_NOTICE.new(:end_task, @clock + current_task.duration, nil))
report()
end
# define an event for ending a task, which decrements the counter
def end_task(_) # _ means ignore any argument
@num_tasks -= 1
report()
end
# define a task as a suitable structure containing start time and duration
task = Struct.new(:start, :duration)
# Create a set of three tasks. I've wired them in, but they could
# be read in or generated dynamically.
task_set = [task.new(2, 5), task.new(4, 23), task.new(7, 4)]
# Add each of the task's start_task event to the priority queue, ordered
# by time of occurrence (as specified in EVENT_NOTICE)
for t in task_set
@pq.push(EVENT_NOTICE.new(:start_task, t.start, t))
end
report()
# Keep popping EVENT_NOTICE's off the priority queue until you run out. For
# each notice, update the @clock and invoke the event contained in the notice
until @pq.empty?
current_event = @pq.pop
@clock = current_event.time
send(current_event.event, current_event.args)
end
我使用Ruby是因为它看起来像伪代码，但实际上可以运行并产生以下输出：
0: 0
2: 1
4: 2
7: 1
7: 2
11: 1
27: 0
我终于花了一些时间来复习二十岁的技能，并用C来实现。结构与Ruby非常相似，但是还有很多细节需要管理。我已将此因素纳入模型，仿真引擎和堆中，以显示执行循环与任何特定模型的细节不同。这是模型实现本身，它说明了构建模型的“事件即功能”的方向。
#include <stdio.h>
#include <stdlib.h>
#include "sim_engine.h"
// define a task as a suitable structure containing start time and duration
typedef struct {
double start;
double duration;
} task;
// stamp out new tasks on demand
task* new_task(double start, double duration) {
task* t = (task*) calloc(1, sizeof(task));
t->start = start;
t->duration = duration;
return t;
}
// create state variables
static int num_tasks;
// provide reporting
void report() {
// print current simulation time & num_tasks
printf("%8.3lf: %d\n", sim_time(), num_tasks);
}
// define an event for ending a task, which decrements the counter
void end_task(void* current_task) {
--num_tasks;
free(current_task);
report();
}
// define an event for starting a task, that increments the num_tasks counter
// and uses the task duration to schedule when this task will end.
void start_task(void* current_task) {
++num_tasks;
schedule(end_task, ((task*) current_task)->duration, current_task);
report();
}
// all event graphs must supply an initialize event to kickstart the process.
void initialize() {
num_tasks = 0; // number of tasks currently active
// Create an initial set of three tasks. I've wired them in, but they could
// be read in or generated dynamically.
task* task_set[] = {
new_task(2.0, 5.0), new_task(4.0, 23.0), new_task(7.0, 4.0)
};
// Add each of the task's start_task event to the priority queue, ordered
// by time of occurrence. In general, though, events can be scheduled
// dynamically from trigger events.
for(int i = 0; i < 3; ++i) {
schedule(start_task, task_set[i]->start, task_set[i]);
}
report();
}
int main() {
run_sim();
return 0;
}
请注意，布局与Ruby实现非常相似。除了具有浮点时间外，输出与Ruby版本相同。 （如果需要，Ruby也会给出小数位，但OP给出的试用任务是不必要的。）
接下来是仿真引擎的头文件和实现。请注意，这是为了将模型构建器与直接使用优先级队列隔离开来。详细信息由schedule()前端处理以将事件放入事件列表，而执行循环则在正确的时间点提取和运行事件。
typedef void (*event_p)(void*);
void initialize();
void schedule(event_p event, double delay, void* args);
void run_sim();
double sim_time();
#include <stdlib.h>
#include "sim_engine.h"
#include "heap.h"
typedef struct {
double time;
event_p event;
void* args;
} event_notice;
static heap_t *event_list;
static double sim_clock;
// return the current simulated time on demand
double sim_time() {
return sim_clock;
}
// schedule the specified event to occur after the specified delay, with args
void schedule(event_p event, double delay, void* args) {
event_notice* en = (event_notice*) calloc(1, sizeof(event_notice));
en->time = sim_clock + delay;
en->event = event;
en->args = args;
push(event_list, en->time, en);
}
// simulation executive loop.
void run_sim() {
event_list = (heap_t *) calloc(1, sizeof(heap_t));
sim_clock = 0.0; // initialize time in the simulation
initialize();
// Keep popping event_notice's off the priority queue until you run out. For
// each notice, update the clock, invoke the event contained in the notice,
// and cleanup.
while(event_list->len > 0) {
event_notice* current_event = pop(event_list);
sim_clock = current_event->time;
current_event->event(current_event->args);
free(current_event);
}
}
最后，优先级队列实现从Rosetta代码中删除了全部权限，进行了重构，并切换为使用void*作为数据有效负载而不是字符串。
typedef struct {
double priority;
void *data;
} node_t;
typedef struct {
node_t *nodes;
int len;
int size;
} heap_t;
void push(heap_t *h, double priority, void *data);
void *pop(heap_t *h);
#include <stdlib.h>
#include "heap.h"
void push(heap_t *h, double priority, void *data) {
if (h->len + 1 >= h->size) {
h->size = h->size ? h->size * 2 : 4;
h->nodes = (node_t *)realloc(h->nodes, h->size * sizeof (node_t));
}
int i = h->len + 1;
int j = i / 2;
while (i > 1 && h->nodes[j].priority > priority) {
h->nodes[i] = h->nodes[j];
i = j;
j = j / 2;
}
h->nodes[i].priority = priority;
h->nodes[i].data = data;
h->len++;
}
void *pop(heap_t *h) {
int i, j, k;
if (!h->len) {
return NULL;
}
void *data = h->nodes[1].data;
h->nodes[1] = h->nodes[h->len];
h->len--;
i = 1;
while (i!=h->len+1) {
k = h->len+1;
j = 2 * i;
if (j <= h->len && h->nodes[j].priority < h->nodes[k].priority) {
k = j;
}
if (j + 1 <= h->len && h->nodes[j + 1].priority < h->nodes[k].priority) {
k = j + 1;
}
h->nodes[i] = h->nodes[k];
i = k;
}
return data;
}
底线：这种事件调度方法非常灵活，对于优先级队列和仿真引擎的给定实现，其实现非常简单。如您所见，该引擎实际上是微不足道的。