c++代码实现带期限作业排序问题

可以使用堆排序算法来实现带期限作业排序问题。具体实现方法如下：

1. 定义一个结构体，包含作业编号、作业期限和作业所需时间三个属性。

2. 将所有作业按照期限从小到大排序。

3. 定义一个最小堆，将第一个作业的所需时间加入堆中。

4. 依次将后面的作业加入堆中，如果当前作业的期限小于等于堆中所有作业的完成时间，则将堆中完成时间最小的作业替换为当前作业。

5. 重复步骤4，直到所有作业都加入堆中。

6. 输出堆中所有作业的编号即可。

以下是示例代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    int deadline;
    int time;
} Job;

void swap(Job* a, Job* b) {
    Job temp = *a;
    *a = *b;
    *b = temp;
}

void minHeapify(Job* jobs, int heapSize, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < heapSize && jobs[left].time < jobs[smallest].time) {
        smallest = left;
    }
    if (right < heapSize && jobs[right].time < jobs[smallest].time) {
        smallest = right;
    }
    if (smallest != i) {
        swap(&jobs[i], &jobs[smallest]);
        minHeapify(jobs, heapSize, smallest);
    }
}

void buildMinHeap(Job* jobs, int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        minHeapify(jobs, n, i);
    }
}

void heapSort(Job* jobs, int n) {
    buildMinHeap(jobs, n);
    for (int i = n - 1; i >= 1; i--) {
        swap(&jobs[0], &jobs[i]);
        minHeapify(jobs, i, 0);
    }
}

void scheduleJobs(Job* jobs, int n) {
    heapSort(jobs, n);
    int* finishTimes = (int*)malloc(n * sizeof(int));
    int* scheduledJobs = (int*)malloc(n * sizeof(int));
    int heapSize = 0;
    int currentTime = 0;
    for (int i = 0; i < n; i++) {
        while (heapSize > 0 && jobs[i].deadline <= currentTime) {
            finishTimes[heapSize - 1] = currentTime;
            scheduledJobs[heapSize - 1] = jobs[0].id;
            swap(&jobs[0], &jobs[heapSize - 1]);
            heapSize--;
            minHeapify(jobs, heapSize, 0);
        }
        if (jobs[i].deadline > currentTime) {
            finishTimes[heapSize] = currentTime + jobs[i].time;
            scheduledJobs[heapSize] = jobs[i].id;
            heapSize++;
            minHeapify(jobs, heapSize, heapSize - 1);
        }
    }
    while (heapSize > 0) {
        finishTimes[heapSize - 1] = currentTime;
        scheduledJobs[heapSize - 1] = jobs[0].id;
        swap(&jobs[0], &jobs[heapSize - 1]);
        heapSize--;
        minHeapify(jobs, heapSize, 0);
    }
    printf("Scheduled jobs: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", scheduledJobs[i]);
    }
    printf("\nFinish times: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", finishTimes[i]);
    }
    printf("\n");
    free(finishTimes);
    free(scheduledJobs);
}

int main() {
    int n;
    printf("Enter the number of jobs: ");
    scanf("%d", &n);
    Job* jobs = (Job*)malloc(n * sizeof(Job));
    for (int i = 0; i < n; i++) {
        printf("Enter the deadline and time for job %d: ", i + 1);
        scanf("%d %d", &jobs[i].deadline, &jobs[i].time);
        jobs[i].id = i + 1;
    }
    scheduleJobs(jobs, n);
    free(jobs);
    return 0;
}

我的第二个问题是：lua closure factory 完整代码